Embracing the 3-Month Rule: A Practical Approach to Unscalable Solutions in Tech Development

In the entrepreneurial landscape, the advice from Paul Graham to “do things that don’t scale” often surfaces, yet the challenge arises in how to effectively apply this principle within the realm of coding.

For the past eight months, I’ve been dedicated to developing my AI podcast platform and have crafted a straightforward framework to navigate the complexities of software development: any unscalable approach gets exactly three months to prove its worth. If it doesn’t demonstrate its value within this timeframe, it’s time to move on.

The start-up Reality

As engineers, we’re conditioned to prioritize scalable solutions from the outset. Concepts like design patterns, microservices, and distributed systems often dominate our thinking. However, this mindset is more reflective of large organizations than agile startups.

In a startup environment, drafting scalable architectures can lead to costly procrastination. We often find ourselves optimizing processes for hypothetical users, which can obstruct genuine progress. By adhering to my 3-Month Rule, I’m compelled to create straightforward, albeit imperfect, code that is deployable and helps establish real user needs.

Key Infrastructure Strategies

Here’s a look at some of my current infrastructure approaches and the rationale behind them:

1. Consolidated Operations on a Single VM
All components—database, web server, background jobs, and caching—operate on a single, cost-effective $40/month virtual machine (VM). While this setup lacks redundancy and relies on manual backups, it has provided invaluable insights into my resource requirements. Analysis over two months revealed that my platform peaks at just 4GB RAM, negating the need for complex orchestration that would have been complicated and unnecessary.

2. Simplified Hardcoded Configurations
By embedding configurations directly into the code, such as pricing tiers and user limits, changes are tracked through Git history and can be evaluated quickly. Although a configuration service would take significant time to set up, I’ve only required three adjustments in three months, saving hours of engineering work for minimal deployment time.

3. Leveraging SQLite for Production
Operating SQLite in a multi-user environment has proven effective, managing 50 concurrent users without difficulty. My usage patterns revealed a significant prevalence of read operations, making SQLite the right choice. Had I opted for a more complex solution like Postgres, I would have wasted time tackling issues that simply didn’t exist in my user interactions.