Embracing the 3-Month Rule: A Pragmatic Approach to Building in Startups

In the world of startup engineering, the adage often quoted is Paul Graham’s insightful counsel: “Do things that don’t scale.” However, how do we apply this advice in the realm of coding? After dedicating eight months to developing my AI podcast platform, I’ve established a straightforward framework: every unscalable method gets a trial period of three months. At the end of this timeframe, it must either demonstrate its value and transition to a more robust structure, or it will be discarded.

As engineers, we are traditionally trained to focus on creating scalable solutions from the outset. This often involves engaging with sophisticated design patterns, microservices, and distributed systems—architectural solutions designed for handling large volumes of users. However, this mindset can lead to what I term “expensive procrastination” in a startup environment. Rather than preparing for hypothetical user bases and solving non-existent issues, our focus should be on practical learning and adapting to real user demands.

Here’s a look at my current infrastructure strategies, which may seem unorthodox but have proven to be quite effective:

1. All-in-One VM Setup

In my current setup, everything—database, web server, background jobs, and Redis—operates on a single VM that costs just $40 a month. Admittedly, this approach lacks redundancy and relies on manual local backups, but the insights gained have been invaluable. Within just two months, I have a clearer understanding of my resource needs than any advanced capacity planning document could provide. My “AI-heavy” platform only peaks at 4GB of RAM, and the complex Kubernetes setup I almost implemented would have managed empty containers.

Every time the system crashes—twice to date—I gather real insights into what actually goes wrong, which, interestingly, is never what I initially anticipated.

2. Hardcoded Configurations

Instead of utilizing configuration files or environment variables, my constants are hardcoded directly into the application. For instance:

python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"

The beauty of this choice? It allows for rapid changes. By simply deploying the code after a modification, I can track every price adjustment through git history, ensuring each alteration is thoroughly reviewed. Rather than spending weeks creating