Embracing the 3-Month Rule: A Framework for Building Scalable Solutions in Tech
In the world of startups, there’s a well-known piece of wisdom from Paul Graham that encourages founders to “do things that don’t scale.” While this advice is often cited, the practicalities of implementing it in the realm of coding remain less discussed. Through my exploration of building an AI podcast platform over the past eight months, I’ve devised a straightforward framework: any approach that can’t scale is given a mere three months to prove its worth. If it fails to demonstrate its value within that timeframe, it’s time to let it go.
As engineers, our training often pushes us to focus on solutions that can handle future scalability from the outset. We’re taught to admire design patterns, microservices, and the intricacies of distributed systems—structures designed to accommodate millions of users. However, this big-business mindset can sometimes be a hindrance in the startup environment. In many cases, building for scalability too soon is simply a form of procrastination; we end up optimizing for imaginary users and preemptively addressing problems that may never arise.
By adhering to my three-month rule, I allow myself to create simpler, more direct code—what some might deem “bad” code. This approach encourages practical shipping of my work, ultimately leading me to understand the real needs of my users. Here’s a look at some of the infrastructure hacks I’ve recently employed and why they offer significant learning opportunities:
1. Consolidation on a Single VM
I currently run my database, web server, background jobs, and caching on a single $40/month virtual machine. While this setup may lack redundancy and relies on manual backups, I’ve gleaned more valuable insights about my resource requirements in two months than any elaborate capacity plan could provide. For instance, I discovered that my platform’s peak memory usage is only 4GB. The complex Kubernetes architecture I almost built would have been managing empty containers instead.
2. Hardcoded Settings Throughout Code
Instead of utilizing configuration files or environment variables, I’ve opted for hardcoded constants in my codebase. For instance:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
This approach may seem rudimentary, but it allows me to swiftly search every aspect of my code and keep track of changes in Git history. Over
One Comment
This post offers a compelling perspective on balancing practical development with long-term scalability. The “3-month rule” is an insightful approach—it encourages rapid experimentation and learning while avoiding the trap of over-engineering early on. I especially appreciate the emphasis on building simple, direct solutions that provide immediate value, which is often overlooked in favor of premature optimization.
Your example of consolidating infrastructure on a single VM highlights an essential lesson: real-world usage and data often reveal the actual needs more effectively than complex setups. It reminds me of the concept of “just enough” architecture, where we prioritize functionality and learning over perfection.
Additionally, the candid use of hardcoded settings underscores that sometimes, simplicity in configuration accelerates development and helps validate core assumptions before investing in more sophisticated methods. Of course, it’s critical to revisit these choices as the platform grows, but your current approach seems pragmatic for a startup phase.
Overall, your framework appreciates the importance of iterative learning, which is vital for startups aiming to build scalable, user-centered solutions without getting bogged down in initial over-planning. Thanks for sharing these practical insights—definitely a valuable mindset for engineers navigating rapid development cycles!