Embracing the 3-Month Rule: A Practical Approach to Building an Unscalable Startup
In the entrepreneurial sphere, Paul Graham’s advice to “do things that don’t scale” often resonates with founders yearning for growth. However, when it comes to actual implementation in programming, the conversation tends to fall short. After dedicating eight months to developing my AI podcast platform, I have devised a straightforward framework: any unscalable strategy is permitted to exist for only three months. At the end of this period, it must either demonstrate its value and be refined or be phased out entirely.
The Reality of Engineering in Startups
As engineers, we are often conditioned to seek out scalable solutions from the outset. We yearn for well-structured microservices, robust architecture, and distributed systems capable of serving millions of users. However, this approach aligns more with the mindset of established organizations than that of startups. In a nascent venture, building scalable code can frequently become an expensive form of procrastination—optimizing for customers who aren’t yet there and addressing challenges that may never arise. My three-month rule compels me to write straightforward, even ‘messy,’ code that genuinely meets user needs.
Current Infrastructure Strategies: Simple Yet Effective
1. Consolidation on One Virtual Machine
I operate my database, web server, background jobs, and caching on a single virtual machine that costs a mere $40 per month. While this setup lacks redundancy and relies on manual backups, it has provided insight into my actual resource requirements. In just two months, I’ve learned that my platform, even with its AI focus, only peaks at 4GB of RAM. The complex Kubernetes framework I was considering would have only meant managing unnecessary containers. When my system crashes—something that has happened twice—I glean valuable insights about actual failures, which are rarely what I anticipated.
2. Hardcoded Configurations Across the Board
Throughout my codebase, key configurations like pricing tiers and maximum users are hardcoded directly into the files, with no configuration files or environment variables to complicate matters. This approach may seem primitive, but it allows for rapid searches across the codebase, tracking every pricing change through Git history. I’ve only modified these constants three times in three months, resulting in a few minutes of redeployment instead of extensive engineering hours.
3. Utilizing SQLite in Production
Yes, I’m running SQLite for a multi-user web application, and it
One Comment
Thank you for sharing such a candid and practical approach to startup engineering. I really appreciate how the 3-month rule encourages founders to prioritize rapid experimentation over premature optimization, which often leads to wasted effort and delayed feedback. Your emphasis on embracing ‘messy’ code and simple infrastructure aligns well with the idea that early-stage products should evolve quickly based on real user insights—scaling efforts can come later once the core value proposition is validated.
Additionally, the willingness to run SQLite in production highlights a focus on value and learning rather than dogmatic adherence to best practices. It reminds us that effective engineering in startups is about pragmatic decision-making; sometimes, the simplest tools and temporary solutions provide the most clarity. This mindset can prevent paralysis by analysis and keep the development process aligned with actual user needs. Thanks again for sharing your framework—definitely a valuable perspective for founders navigating the tension between speed and scalability at the early stage.