Embracing the 3-Month Rule: A Practical Approach to Non-Scalable Solutions in Software Development
In the world of software development, the advice from Paul Graham resonates with many: “Do things that don’t scale.” However, the challenge arises when it comes to the actual implementation of this principle, especially when coding. As I embark on my journey of building an AI podcast platform, I’ve crafted a straightforward yet effective framework: every unscalable hack is given a lifespan of three months. If it proves its worth, it gets refined; if not, it is discarded.
Rethinking Scalability
As engineers, our training often emphasizes creating scalable solutions from the outset. We immerse ourselves in sophisticated design patterns, contemplate robust microservices, and dream of creating systems that can support millions of users. However, this mindset can be counterproductive in a startup environment where premature scaling can often lead to wasted resources. My three-month rule compels me to produce straightforward, quick-to-ship code that provides clear insights into users’ actual needs.
Key Infrastructure Hacks and Their Strategic Value
1. Unified VM Infrastructure
Currently, my entire system—database, web server, background tasks, and caching—resides on a single $40/month virtual machine. While this setup lacks redundancy and relies on manual backups, it has been a revelation. In just two months, I’ve acquired invaluable insights into my resource requirements. Initially, I was tempted to deploy a complex Kubernetes architecture, but it turns out that my platform’s peak usage is just 4GB of RAM. The crashes have provided unexpected lessons about where my actual vulnerabilities lie, often deviating from my initial assumptions.
2. Simplified Configuration Management
My approach to configuration is decidedly low-tech: hardcoded values scattered throughout my codebase. While conventional wisdom would advocate for using configuration files or environment variables, this method allows me to efficiently track changes, as each modification is logged in my Git history. In three months, I’ve altered configuration settings only three times, saving me countless hours of engineering effort that would have gone into building an elaborate management system.
3. Employing SQLite in Production
I chose SQLite for my multi-user web app, and it has proven surprisingly effective. With a compact database size of 47MB, it seamlessly accommodates 50 concurrent users. This choice has illuminated my access patterns, revealing a 95% read to 5% write ratio. Had I opted for a heavier database system like
One Comment
This post offers a refreshing perspective on how startups and engineers can pragmatically approach scaling. The three-month rule is a thoughtful heuristic that emphasizes learning through quick iteration and validation, rather than prematurely building for scale. I particularly appreciate the emphasis on simplicity—like using a single VM or SQLite—to gain a clear understanding of actual resource needs before investing in more complex infrastructure.
One insight to consider is how this approach can be complemented with incremental automation. For instance, as certain unscalable hacks prove their worth, gradually automating and refining them can provide a middle ground—preserving the agility of quick experimentation while setting the stage for eventual scalability. Also, documenting the decision-making process during these three months can create a valuable knowledge base for future scaling efforts, helping to avoid re-deriving lessons learned.
Overall, adopting a mindset that values learning and lean experimentation early on can significantly reduce waste and accelerate product-market fit. Thanks for sharing this thoughtful framework—it’s an empowering reminder that sometimes, doing less (but smarter) is the best path forward.