Embracing the 3-Month Rule: A Pragmatic Approach to Unscalable Development
In the startup landscape, renowned entrepreneur Paul Graham famously advised entrepreneurs to “do things that don’t scale.” While this wisdom is widely acknowledged, there’s a surprising lack of discourse on how to effectively implement this philosophy in the realm of software development.
Having spent the past eight months developing my AI podcast platform, I’ve devised a straightforward framework: each unscalable tactic I adopt is given a lifespan of three months. At the end of this period, it must either demonstrate its value and evolve into a more robust solution or be discarded.
Why Traditional Development Approaches Can Fall Short
As engineers, we are often conditioned to prioritize scalable solutions right from the outset. We delve into design patterns, microservices, and distributed systems—techniques that are optimal for handling millions of users. However, this mindset can be counterproductive for startups. Often, scalable coding becomes a form of costly procrastination as we attempt to anticipate the needs of future users who may never materialize. My 3-month rule encourages me to create straightforward, if imperfect, code that can be deployed immediately, allowing for valuable insights into real user needs.
Insights from My Current Development Hacks
1. Consolidated Infrastructure on a Single VM
I currently host my entire application stack—including the database, web server, and background jobs—on one affordable $40/month virtual machine (VM). While this setup lacks redundancy and relies on manual backups, it possesses a hidden brilliance. In just two months, I’ve gained invaluable insights into my resource requirements. For instance, it turns out my AI-centric platform only spikes to 4GB of RAM. The intricate Kubernetes architecture I considered would have been a waste of resources managing idle containers. Crashes are informative; they reveal unexpected vulnerabilities rather than the anticipated issues.
2. Hardcoded Configuration Values
My configuration values, such as subscription prices and user limits, are hardcoded directly into the application. There’s no complex configuration file or a sea of environment variables; rather, constants reside throughout the codebase. Although this approach might seem primitive, it allows me to quickly locate and track configuration changes through Git history. With only three updates in three months, this method saves significant engineering time—my 15 minutes of redeployment is far more efficient than a week spent on building a configuration service.
3. SQLite as My Production Database
Surprisingly, I’ve chosen to run
One Comment
This is an insightful approach that highlights the importance of rapid experimentation and learning in early-stage development. The 3-month rule creates a healthy pressure to validate or pivot ideas without over-investing in unproven solutions. Your use of simple, cost-effective infrastructure like a single VM and hardcoded configs exemplifies how focusing on immediate value and real-world insights can outweigh the lure of highly scalable but potentially premature solutions. It reminds me that often the best way to build scalable systems is to first understand the actual needs and behaviors of users — and that can only come from getting a minimally viable product into their hands quickly. Embracing unscalable tactics as temporary steps allows for agility and continuous learning, which are crucial in startups. Thanks for sharing this practical framework!