Embracing the 3-Month Rule: A Pragmatic Approach to Unscalable Solutions
In the startup realm, the mantra “Do things that don’t scale,” as popularized by Paul Graham, is often thrown around. Yet, the specifics of applying this wisdom in technical environments remain less frequently discussed. I’ve been immersed in developing my AI podcast platform for the past eight months, during which I’ve crafted a straightforward methodology: any temporary, non-scalable workaround gets a three-month trial period. At the end of this period, if the solution has demonstrated its worth, it gets more robust development; otherwise, it gets retired.
As engineers, we often fall into the trap of designing for scalability from the outset. Concepts like microservices and distributed systems focus on accommodating vast user bases. However, this mindset is usually best suited for larger enterprises, whereas startups frequently find that spending time and resources on scalable architectures is often a distraction.
Implementing my 3-month rule compels me to embrace simpler, more direct solutions that deliver results in real time and provide genuine insights into user needs.
My Current Unscalable Solutions and Their Unexpected Benefits
1. Single Virtual Machine Operation
All components of my platform—including the database, web server, and background jobs—reside on a single $40/month virtual machine. No redundancy is in place, and I manually back up data to my local machine.
Counterintuitively, this approach has illuminated my actual resource requirements far more effectively than conventional capacity planning methods. Within just two months, I’ve discovered that my “AI-heavy” platform peaks at 4GB of RAM. The intricate Kubernetes deployment I considered would have involved managing unnecessary resources.
When my system encounters issues (which it has twice), I gain invaluable data about failure points—often, they are not what I anticipated.
2. Hardcoded Configuration
I keep all configurations hardcoded within my application, such as pricing tiers and user limits. This means any adjustments require a republish.
The advantage? I can quickly search my entire codebase for configuration values, making changes traceable in git history. In the last three months, I have made only three configuration alterations, saving me the considerable time it would have taken to build a dedicated configuration service.
3. Using SQLite in Production
I decided to run SQLite for a multi-user web application, which has proven efficient with a database size of just 47MB. It comfortably manages 50 simultaneous users
One Comment
This post offers a compelling perspective on the value of applying unscalable, rapid experimentation tactics in early-stage development. The 3-month rule serves as a pragmatic checkpoint, allowing startups to iterate quickly without the overhead of optimizing for scalability prematurely. I particularly appreciate the emphasis on gaining real-world insights through simple solutions, such as running a single VM or using SQLite in production—approaches that often reveal actual resource needs and user behavior more effectively than theoretical models.
This methodology aligns well with the broader principle of building with just enough complexity to test assumptions, then iterating towards more scalable solutions once the core value proposition is validated. It’s a reminder that initial focus should be on delivering value and learning quickly, rather than over-engineering from the start. Have you considered documenting specific metrics or success criteria at the end of each 3-month cycle? That could further formalize the process and help identify when a transition to more scalable infrastructure is truly warranted.