The 3-Month Rule: A Pragmatic Approach to Coding for Startups

In the world of startups, the mantra of “doing things that don’t scale,” as famously stated by Paul Graham, is often echoed but seldom explored in the realm of coding practices. After dedicating over eight months to developing my AI podcast platform, I’ve crafted a straightforward approach to implementing this advice: every unscalable hack I employ is given a lifespan of just three months. At the end of that period, we evaluate its effectiveness—if it proves valuable, we invest in a more robust solution; if not, it’s discarded.

As software engineers, we tend to focus on creating scalable solutions from the outset. We dive into design patterns, microservices, and robust architectures that can support vast numbers of users. However, this mentality is often more aligned with large organizations than with startups. In the early stages of a startup, focusing on scalability can lead to considerable expenses while deferring critical decisions.

The three-month rule encourages me to produce straightforward, albeit imperfect, code that delivers results in a timely manner. This approach not only aids in rapid iterations but also reveals what users genuinely need.

Infrastructure Hacks That Are Actually Strategic

Here are some of the unscalable techniques I’ve implemented, which may initially seem impractical but have proved to be invaluable learning tools:

1. Single-VM Architecture

All components of my platform, from the database to the web server and caching mechanism, operate on a single $40/month virtual machine. While this setup lacks redundancy and relies on manual backups, it has offered profound insights into my resource requirements. In just two months, I’ve learned that my system peaks at 4GB of RAM. The complex Kubernetes infrastructure I almost opted for would have been a burden, managing idle containers instead of addressing my needs directly.

2. Hardcoded Configuration

By embedding configuration settings directly into my code, such as pricing tiers and maximum user limits, I’ve simplified the process of tracking these values. While this may seem counterproductive, it enhances visibility and allows for rapid adjustments. In the last three months, I’ve only changed these values three times; this minor effort significantly outweighs the time that would’ve been consumed in engineering a dedicated configuration service.

3. Using SQLite for Production

My choice of SQLite for a multi-user web application, with a mere 47MB database, has yielded a surprising level of performance, accommodating 50 concurrent users