Embracing the 3-Month Rule: A Pragmatic Approach to Unscalable Solutions in Tech Development
In the world of startups, we often come across the invaluable advice from Paul Graham: “Do things that don’t scale.” However, implementing this principle in the realm of coding isn’t widely discussed. Drawing from my own experience over the past eight months of building an AI podcast platform, I’ve devised a straightforward framework that has proven effective: every unscalable solution I implement is given a lifespan of three months. After this period, we evaluate its effectiveness—if it demonstrates substantial value, we refine it; if not, it’s time to say goodbye.
As software engineers, we are typically trained to engineer scalable solutions from the outset. Concepts like design patterns, microservices, and distributed systems are often part of our toolkit, geared towards accommodating millions of users. However, this mindset can lead to premature optimizations and unnecessary complexity in startup environments. Often, scalable code becomes an expensive form of procrastination, tackling problems we may not yet even face.
By adhering to my three-month rule, I prioritize writing straightforward, albeit imperfect, code that delivers tangible results and helps illuminate the actual needs of our users. Here’s a glimpse into my current infrastructure choices and why they exemplify sound decision-making:
1. Consolidated Operations on a Single VM
I have everything—from the database and web server to background jobs and Redis—running on a single virtual machine costing only $40 a month. There’s no redundancy, and I conduct manual backups.
This may sound inefficient, but it’s been quite illuminating. Within just two months, I’ve gained more insight into my actual resource needs than any formal capacity planning document could provide. For instance, my “AI-heavy” platform peaks at just 4GB of RAM. The complex Kubernetes setup I almost implemented would have resulted in managing empty containers instead of addressing real issues.
2. Hardcoded Configuration
Configurations are hardcoded directly into the codebase—no separate config files or environment variables. A change necessitates a simple redeployment.
This approach may seem archaic, but it offers hidden advantages. I can quickly search through my entire codebase for any configuration values and track every change through Git history. In the last three months, I’ve only needed to update these values three times, translating to just 15 minutes of redeployment instead of countless engineering hours to build a fancy configuration service.
