Embracing the 3-Month Rule: A Pragmatic Approach to Building Scalable Solutions
In the world of technology startups, the advice from Paul Graham to “do things that don’t scale” is widely recognized but seldom explicated, particularly regarding practical implementation in coding. Having spent the last eight months developing my AI podcast platform, I’ve devised a straightforward framework that I call the “3-Month Rule.” This guideline stipulates that any initial unscalable hack is allowed to persist for three months. After this period, we must assess whether it has demonstrated its value and warrants a proper build-out, or whether it should simply be discarded.
The Startup Dilemma: Balancing Scalability and Procrastination
As software engineers, we are often conditioned to prioritize scalable architecture from the outset—think along the lines of microservices, distributed systems, and the intricacies of design patterns. While this approach is suitable for larger enterprises, startups frequently face a different reality. In our formative stages, developing scalable solutions can sometimes translate to costly procrastination. Rather than fine-tuning systems for potential future users, my 3-month rule compels me to produce straightforward, tangible code that not only gets deployed but also facilitates a deeper understanding of user needs.
Current Hacks: Why They’re Smart Choices
1. Unified Virtual Machine Setup
All components—including the database, web server, background jobs, and Redis—operate on a single $40/month virtual machine. While this may initially seem reckless due to a lack of redundancy and reliance on manual backups, it presents a valuable learning opportunity. In two months, I gained better insight into my actual resource consumption than any theoretical planning could have offered. My platform’s demands peaked at 4GB of RAM, meaning an elaborate Kubernetes setup would have only managed underutilized containers.
2. Hardcoded Configuration
My configuration values are hardcoded throughout the codebase, eliminating the need for external files or environment variables. Modifying any settings necessitates a redeployment. The efficiency in this approach is profound: I can swiftly locate any config value within seconds using grep. For the few changes made over three months, this method has proven to be vastly more efficient in both time and computational resources than developing a full configuration service.
3. SQLite in Production
Utilizing SQLite for this multi-user application may seem unconventional, yet my entire database occupies a mere 47MB and effectively manages up to 50 concurrent users
One Comment
Thank you for sharing this practical and insightful approach with the “3-Month Rule.” It highlights a crucial balance many startups and developers grapple with: the tension between rapidly validating ideas and investing in scalable architecture early on. Your emphasis on embracing initial hacks to learn and iterate quickly resonates deeply, especially with the reality that early-stage products often prioritize speed and learning over perfection.
I particularly appreciate how your examples—like using a single VM, hardcoded configs, and SQLite—serve as pragmatic trade-offs that foster agility. These decisions, while not scalable long-term, enable rapid deployment, quick iteration, and a deeper understanding of real user needs before investing heavily in infrastructure. It’s a reminder that “doing things that don’t scale” isn’t just about reckless shortcuts but strategic choices driven by current goals.
This framework underscores the importance of disciplined reflection—after three months, assessing whether these hacks provide enough value and insights to warrant investment in scalability or if they should be discarded. It’s a disciplined yet flexible approach that can accelerate learning and reduce unnecessary complexity early on, which ultimately leads to more informed scaling decisions later. Thanks again for sharing this valuable perspective!