Embracing the 3-Month Rule: A Pragmatic Approach to Building Scalable Solutions
In the entrepreneurial landscape, the advice that resonates most is often the simplest: “Do things that don’t scale.” This wisdom by Paul Graham is commonplace among startups, yet the discussion seldom delves into the practicalities of its implementation within the realm of coding.
Having dedicated eight months to developing my AI podcast platform, I’ve cultivated a straightforward framework inspired by this principle: each unscalable hack is given a lifespan of just three months. After this period, each solution must either validate its worth through tangible results and evolve into a robust offering, or face removal.
It’s essential to recognize that as engineers, we are trained to design solutions that prioritize scalability from the outset. The allure of sophisticated architecture—think microservices and distributed systems—fosters a mindset focused on accommodating imaginary future users. However, at a startup, this approach can often lead to costly delays while we preemptively solve problems that may never materialize. The 3-month rule compels me to adopt a more straightforward coding style—delivering “imperfect” code that can be deployed quickly and ultimately clarifies actual user needs.
My Strategic Hacks and Their Hidden Benefits:
1. Consolidation on a Single Virtual Machine
Currently, I have all aspects—database, web server, background jobs, and caching—operating on one $40/month virtual machine. This setup lacks redundancy and relies on manual backups to my local environment.
Why is this innovatively strategic? I’ve gained deeper insights into my app’s resource needs over the past two months than any formal capacity planning exercise could provide. My initially anticipated high demands resulted in a maximum peak of just 4GB of RAM usage. Had I opted for a complex Kubernetes configuration, I would only be managing idle containers.
When that single VM does crash (which it has twice), I’m provided with real-world data about the actual points of failure—often not what I expected.
2. Hardcoded Configuration Values
Instead of using configuration files or environment variables, I’m relying on hardcoded constants like:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
This design choice allows me to quickly search my entire codebase for any configuration parameter. With each change tracked in git history, my updates undergo code review
One Comment
This is a compelling approach that truly encapsulates the essence of “doing things that don’t scale” in a practical, disciplined manner. The 3-month rule acts as a powerful feedback loop—encouraging quick deployment, real-world validation, and continuous iteration without getting bogged down in over-engineering. I particularly appreciate the emphasis on gaining hands-on insights through simple setups, such as consolidating everything on a single VM, which aligns well with the startup philosophy of “test fast, iterate faster.”
A thought to consider: as you progress, you might find value in gradually introducing automation for backups and monitoring—even small steps that can scale with your application’s growth. Additionally, once you validate your core hypotheses and find predictable patterns, transitioning to more scalable infrastructure can be planned systematically, informed by the data you’ve collected early on. Overall, this pragmatic balance between simplicity and experimentation is a powerful template for startup engineering.