Embracing the 3-Month Rule: A Practical Approach to Unscalable Solutions in Tech
In the tech world, many entrepreneurs and developers are familiar with the wisdom imparted by Paul Graham: “Do things that don’t scale.” However, the execution of this advice, particularly in software development, is often overlooked. After eight months of building my AI podcast platform, I’ve crafted a straightforward framework: every non-scalable approach is given a lifespan of just three months. By the end of this period, it must either demonstrate its value and be developed further or be phased out.
As engineers, we often gravitate toward scalable solutions from the outset—embracing design patterns, microservices, and complex architectures capable of accommodating millions of users. While this is crucial in large corporations, such thinking can introduce unnecessary complexities at a startup level. In these early stages, prioritizing scalable code can often mean procrastinating; we risk devoting time to optimizing systems for imagined users while neglecting the actual needs of our existing customer base.
Letting Go of Perfection: My Infrastructure Hacks
Here’s a glimpse into my current infrastructure decisions and why I believe they are strategically advantageous:
1. Simplified Setup on a Single VM
I’ve consolidated my database, web server, background jobs, and caching on one $40/month virtual machine. While this approach lacks redundancy and relies on manual backups, the insights gained in two months have far surpassed any extensive capacity planning. Surprisingly, my resource usage peaks at merely 4GB of RAM—my initial thoughts of requiring a complex Kubernetes setup were misguided.
What’s more, when system crashes occur (and they have, twice), I’m equipped with real data on what exactly failed. Spoiler: it’s often not what I anticipated.
2. Directly Hardcoded Configurations
Configurations are explicitly defined within the code, which may seem primitive but has its advantages. By eliminating configurational files or environment variables, I can quickly search for any value using simple grep commands. Additionally, every change is neatly tracked in Git history, and my self-reviews allow for thorough oversight.
Over the past three months, I’ve adjusted configurations only three times. This minimal adjustment time dramatically outweighs the hours it would have taken to develop a dedicated configuration service.
3. Utilizing SQLite in Production
My multi-user web app is powered by a 47MB SQLite database, comfortably handling concurrency with 50 users. Through this approach
One Comment
This is a compelling and pragmatic approach that highlights the importance of prioritizing immediate value over theoretical scalability in early-stage projects. The 3-month rule acts as a healthy catalyst for rapid experimentation, allowing teams to validate assumptions and learn quickly without getting bogged down in unnecessary complexity.
Your infrastructure choices, such as consolidating everything onto a single VM and using SQLite for multi-user access, demonstrate a focused understanding that often, “less is more” during initial phases. This aligns well with the idea that understanding actual user needs and real-world system behavior can provide more actionable insights than over-engineering from the start.
It would be interesting to explore how you plan to transition from these unscalable solutions as you scale, perhaps selectively adopting more resilient architectures only when the growth justifies it. Overall, your framework offers a valuable reminder to embrace simplicity and practical experimentation—two often overlooked drivers of startup agility.