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
