Embracing the 3-Month Rule: A Pragmatic Approach to Unscalable Solutions
In the realm of startup development, the well-known advice from Paul Graham to “do things that don’t scale” resonates deeply. However, the practical application of this principle in the coding arena often goes unaddressed. After eight months of building my AI podcast platform, I’ve established a straightforward framework: any unscalable workaround is given a lifespan of three months. At the end of this period, a decision must be made: either the solution demonstrates its value and is transformed into a robust implementation, or it is discarded.
As engineers, we typically aim for scalable solutions from the outset. Whether it’s leveraging design patterns, crafting microservices, or establishing distributed systems, we nurture architectural frameworks designed to support millions of users. This method, however, is largely suited for larger companies.
In a startup setting, prioritizing scalability can frequently lead to costly delays. It’s about anticipating user demands that may never materialize and addressing issues that might not even exist at the moment. My three-month approach compels me to adopt straightforward and, yes, “imperfect” code that swiftly delivers results and reveals the genuine needs of my users.
Current Infrastructure Tweaks: A Clever Perspective
1. Consolidating Everything on a Single VM
I currently run my database, web server, background jobs, and caching on one $40/month virtual machine with no redundancy, relying on manual local backups.
What may seem like a reckless design choice is, in fact, a practical strategy. Over the last couple of months, I’ve gleaned more insights about my resource requirements than any extensive capacity planning document could have provided. Surprisingly, my so-called “AI-heavy” platform only spikes at 4GB of RAM usage. The intricate Kubernetes architecture I nearly implemented would have simply managed idle containers.
Despite experiencing a couple of crashes, each incident has armed me with invaluable data that reveals what actually fails—often unexpected elements.
2. Hardcoded Configurations
Instead of utilizing configuration files or environment variables, I have constants directly embedded in the code:
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
This might seem like a setback, but it offers a hidden advantage: I can quickly search my entire codebase for any configuration values. Each price
One Comment
Thank you for sharing this thoughtful approach. The 3-month rule effectively underscores the importance of validating assumptions quickly and iterating rapidly—especially in a startup environment where resources and time are limited. Your focus on embracing “imperfect” solutions for a short period allows for real-world learning that can prevent overengineering at early stages.
I appreciate the pragmatic decisions you’ve made, like consolidating everything on a single VM and hardcoding configurations. While these might seem unscalable in the long run, they offer immediate feedback and simplify troubleshooting—crucial in the initial phases. This approach aligns well with the concept that building scalable systems should ideally be driven by genuine user demand rather than speculation.
Looking ahead, it might be valuable to regularly revisit these choices—after the three-month mark—to assess whether they’ve become bottlenecks or if further refinement is necessary. This disciplined cycle of experimentation, measurement, and pivoting embodies a lean startup mindset that can lead to more sustainable growth down the line. Keep up the great work!