The 3-Month Rule: A Practical Framework for Building Unscalable Solutions
In the realm of startups, one piece of advice often echoed by tech luminaries such as Paul Graham is to “do things that don’t scale.” While this mantra resonates widely, its execution—especially in the coding phase—is rarely discussed. After spending eight months developing my AI podcast platform, I’ve crafted a straightforward framework to channel this philosophy effectively: each unscalable approach enjoys a three-month lifespan before either proving its worth or being retired.
As software engineers, we’re conditioned to prioritize scalable solutions from the outset. We’re captivated by complex design patterns, microservices, and distributed systems designed to cater to millions of users. However, this mindset often aligns more with large corporations than with startups. In a fledgling venture, focusing on scalability can just as easily transform into expensive procrastination, wherein we optimize for users who haven’t yet arrived and solve imaginary problems.
My three-month rule compels me to write simple, direct code—what might often be deemed “bad” code—that actually gets deployed. This iterative approach not only counters the impulse to over-engineer but also provides valuable insights into user needs that only arise through real-world use.
Current Infrastructure Hacks That Offer Surprising Insights
1. Single VM Deployment
I operate my entire platform on a singular $40/month virtual machine, hosting the database, web server, background jobs, and Redis—all together, without redundancy and backed up manually to my local drive. Why is this a savvy choice? It has illuminated my resource needs quicker than any complicated capacity planning document ever could.
In just two months, I learned that my “AI-heavy” platform peaks with only 4GB of RAM usage. Had I implemented a complex Kubernetes setup as initially intended, I would likely have been managing empty containers instead of addressing real challenges. Each time this system fails (twice so far), I gain insight into breakdowns that are often unexpected.
2. Simplified Configuration Management
Instead of using configuration files or environment variables, I’ve opted for hardcoded constants scattered throughout my codebase:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
This approach means that updating any configuration requires a redeployment, but it also provides a hidden benefit. I can swiftly search through my entire codebase
One Comment
This post offers a valuable reminder that, especially in early-stage startups, rapid experimentation often trumps immediate scalability. The 3-month rule serves as a practical approach to balance quick deployment with iterative learning—allowing founders and engineers to focus on real user feedback rather than over-engineering from the outset.
I particularly appreciate the emphasis on “bad” code and minimal infrastructure as tools for gaining rapid insights. For many teams, premature optimization can be a costly distraction; instead, embracing simple deployments like a single VM and hardcoded configs can reveal what truly matters before investing in complex systems.
One insight I’d add is the importance of documenting and reviewing these unscalable solutions periodically. After each three-month cycle, reflecting on what worked, what didn’t, and what should be retained or replaced can foster a disciplined yet flexible development mindset. Ultimately, this approach supports a philosophy of lean experimentation that can lead to more robust, scalable solutions built on validated assumptions.