Embracing the 3-Month Rule: A Strategic Approach to Unscalable Development
In the world of startups, the conventional wisdom often echoes Paul Graham’s famous mantra: “Do things that don’t scale.” While this advice is widely known, the practicalities of applying it in a software development context are rarely discussed. After spending the last eight months developing my AI podcast platform, I’ve established an insightful framework: every unscalable approach is given a three-month trial period. At the end of that timeframe, it either demonstrates its value and gets a proper development overhaul, or it is discarded.
As software engineers, we are conditioned to aspire toward constructing scalable architectures from the outset—envisioning sophisticated designs like microservices and distributed systems capable of accommodating vast user bases. However, that mindset often belongs to larger organizations, where scalability is paramount. Within the startup environment, investing time in scalable code may turn out to be futile procrastination, focusing on users that don’t yet exist and tackling problems that may never arise. By adhering to my three-month rule, I find myself creating simple, straightforward, and intentionally “bad” code that not only ships but also provides invaluable insights into user needs.
My Current Infrastructure Strategies and Their Benefits:
1. Unified Virtual Machine Management
Everything from the database to the web server and background jobs runs on a single $40-per-month virtual machine. This means there’s no redundancy, and I perform manual backups to my local device.
Despite appearances, this setup is ingenious. In just two months, I’ve gained more awareness of my actual resource demands than any detailed capacity plan could provide. For instance, my “AI-heavy” platform peaks at only 4GB of RAM. The complex Kubernetes infrastructure I considered would have required me to manage a flurry of idle containers.
When the system has crashed (which has happened twice thus far), I obtained genuine data regarding the true points of failure—insights that often surprised me.
2. Hardcoded Configuration Management
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
By placing essential configurations as constants throughout the codebase, without environment variables or dedicated config files, any adjustment necessitates a redeployment.
The brilliance of this method lies in its simplicity: I can quickly search my entire codebase for any configuration value in moments
One Comment
This is a compelling approach that highlights the importance of rapid learning and validation in early-stage development. Your 3-month rule effectively balances the need for experimentation with the pragmatic reality of limited resources, allowing startups to gather concrete insights before investing in complex architectures. I particularly appreciate how your infrastructure choices—like a single VM and hardcoded configs—prioritize speed and simplicity, which can be invaluable for understanding user behavior and system bottlenecks firsthand.
This mindset aligns well with lean startup principles: build fast, test quickly, and iterate based on real data. It’s a reminder that sometimes, “bad” code or simple setups aren’t liabilities but stepping stones toward scalable solutions. As growth becomes clear, you can then strategically refactor and scale—with confidence that your foundational understanding is solid. Thanks for sharing such practical insights—it’s inspiring for engineers navigating the tension between immediate needs and future scalability.