The 3-Month Approach: A Pragmatic Framework for Navigating Non-Scalable Solutions
In the entrepreneurial realm, Paul Graham’s advice to “do things that don’t scale” frequently echoes, yet the execution of this principle in coding often goes unexamined. After dedicating eight months to developing my AI podcast platform, I have cultivated a straightforward framework: each unscalable workaround is given a lifespan of just three months. At the end of this period, the solution must either demonstrate its worth and be formalized or be discarded.
As engineers, we are often conditioned to prioritize scalable solutions right from the onset. We are attracted to sophisticated design patterns, microservices, and distributed systems—architectures fit for handling millions of users. However, this mindset aligns more with established corporations and their needs rather than startups, where scalable coding can often become a costly delay. In fact, my three-month framework encourages me to embrace simpler, straightforward, and even “imperfect” code that delivers real results and helps me better understand the needs of my users.
Current Infrastructure Strategies That Prove Effective
1. Consolidated on a Single VM
My entire setup—database, web server, background jobs, and Redis—operates on a single $40-per-month virtual machine. This approach may lack redundancy and involves manual local backups, but its simplicity has provided invaluable insights. I’ve gained a deeper understanding of my actual resource needs in just two months compared to what extensive capacity planning documentation might have offered. My so-called “AI-heavy” platform has shown to peak at merely 4GB of RAM, and the elaborate Kubernetes configuration I nearly implemented would have led to managing empty containers.
When the system crashes (yes, that has happened a couple of times), I receive concrete data on the actual points of failure—revealing surprises each time.
2. Hardcoded Configuration
Instead of using configuration files or environmental variables, I rely on hard-coded constants throughout my codebase:
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
While this may seem crude, it offers a hidden advantage: I can quickly search my entire codebase for any configuration value in seconds. Each price adjustment is meticulously recorded in version history, and every update undergoes a code review process—albeit one I conduct myself.
Creating a dedicated configuration service would
One Comment
This post offers a compelling perspective on balancing the urgency of delivering value with the discipline of technical rigor, especially in startup environments. The three-month rule is a pragmatic approach that encourages rapid experimentation and immediate insight, while avoiding the trap of over-engineering early on. I especially appreciate the emphasis on simplicity—using a single VM and hardcoded configurations to keep things lean and focused on learning.
One point worth highlighting is the importance of establishing a process to reassess these solutions at the end of each cycle. Not every quick fix will withstand the test of time, but frequent evaluations can help identify patterns or recurring issues that warrant more scalable solutions. Additionally, documenting these short-term solutions and their underlying assumptions can prevent technical debt accumulation later, even if they are intentionally temporary.
Overall, this framework promotes a healthy entrepreneurial mindset—prioritize delivering results, learn fast, and scale thoughtfully when the time is right. It’s a valuable reminder that sometimes, the most efficient path to understanding and growth isn’t to build the perfect system from day one, but to iterate swiftly while keeping an eye on long-term sustainability.