The Three-Month Rule: A Pragmatic Approach to Unscalable Development
In the entrepreneurial landscape of tech startups, one piece of wisdom stands out from the renowned Paul Graham: “Do things that don’t scale.” While this advice is widely acknowledged, the challenge remains in putting it into practice, especially within the realm of coding and system architecture.
Over the past eight months, as I’ve been crafting my AI podcast platform, I’ve devised a straightforward but effective framework: any unscalable solution I implement is given a lifespan of three months. If it demonstrates its worth by that time, it will be properly built out; otherwise, it will be phased out.
Rethinking Scalability in Startups
As engineers, our instincts often lead us toward creating scalable systems from the outset. Concepts like design patterns, microservices, and distributed architectures are standard fare, especially suited for larger companies. However, in the startup environment, obsessing over scalability can be a costly form of procrastination. We tend to optimize for imaginary users and hypothetical issues, which may never arise.
By adhering to my three-month rule, I’m compelled to prioritize simple and direct solutions that can be deployed swiftly. This approach allows me to engage with real user feedback, revealing genuine needs rather than assumptions.
Current Infrastructure Strategies: Learning Through Simplicity
1. Consolidation on a Single VM
At the core of my operations is a solitary $40/month virtual machine running everything—database, web server, background tasks, and caching—without redundancy. While this setup may appear risky, it has proven invaluable. In just two months, I’ve garnered more insight about my resource requirements than any capacity planning document could provide. My so-called “AI-heavy” platform operates effectively on just 4GB of RAM, making the complex Kubernetes architecture I nearly implemented unnecessary.
Each crash teaches me about unexpected failure points, illuminating the actual demands of my system.
2. Hardcoded Configurations
I rely on hardcoded values scattered throughout my codebase—constants that dictate pricing, user limits, and model selection. This method might lack elegance, but it offers efficiency. It’s possible to quickly search for configuration settings, and every alteration is logged in Git history. Over three months, I adjusted these values only three times, yielding a mere quarter-hour of redeployment versus the 40 hours that a dedicated configuration system would have cost.
3. Utilizing SQLite in Production
In an unconventional choice, I
One Comment
This post offers a refreshing perspective on the practical realities faced by startups and solo developers. I particularly appreciate the emphasis on rapid experimentation and learning through simplified infrastructure—it’s a mindset that can prevent analysis paralysis and foster quick iteration.
The three-month rule acts as an effective boundary to prevent over-engineering, ensuring that solutions are evaluated against real-world performance and user feedback rather than assumptions. Your approach of using a single VM and hardcoded configs exemplifies how embracing minimalism can yield valuable insights early on.
As startups scale, of course, revisiting these decisions becomes essential, but your framework wisely prioritizes action and adaptation over premature optimization. It’s a great reminder that understanding actual needs through simple, unscalable solutions often provides more clarity than complex architectures built on speculation. Thanks for sharing this pragmatic strategy!