Embracing the 3-Month Rule: A Practical Approach to Unscalable Solutions in Tech
In the tech industry, the mantra of “do things that don’t scale,” popularized by Paul Graham, often sparks discussions around startup strategies. However, implementing this concept, particularly in coding and development strategies, rarely gets the attention it deserves. After dedicating the last 8 months to developing my AI podcast platform, I have adopted a straightforward framework: every unscalable hack I implement is given a lifespan of three months. After this period, I evaluate whether it has demonstrated its worth and deserves further investment, or if it should be discarded.
As developers, our education primes us to prioritize scalable solutions from the outset. We admire sophisticated architecture, employing design patterns, microservices, and distributed systems—you name it. Yet, such an approach is often more suitable for larger organizations. In a startup environment, aiming for scalability too early can lead to unnecessary delays and costs. My three-month rule helps me focus on deploying straightforward, though possibly inelegant, code that helps clarify real user requirements.
My Current Infrastructure Hacks and Their Hidden Benefits:
1. Single Virtual Machine for All Operations
I run my entire platform—including the database, web server, background jobs, and Redis—on one cost-effective VM for about $40 monthly. This setup has zero redundancy and relies on manual backups to my local computer.
What some may see as a flawed approach has proven effective in assessing my actual needs. Over a couple of months, I’ve gained insights into my resource utilization—my AI-heavy platform, for instance, only requires 4GB of RAM at peak times. The complex Kubernetes environment I contemplated would have resulted in wasted resources. Each time the system experiences a crash (which has happened twice), I acquire invaluable data on what truly fails. Spoiler: it’s rarely what I initially anticipated.
2. Hardcoded Configuration for Quick Adjustments
Instead of relying on configuration files or environment variables, my codebase features constants defined directly within the code:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
While this may seem inefficient, it allows me to quickly search through my codebase for any configuration value, and I can track changes via git history. Over three months, I’ve only made three updates, amounting to 15
One Comment
This is an insightful approach that challenges the conventional wisdom around immediate scalability. I particularly appreciate the disciplined use of the 3-month rule—it balances experimentation with accountability, preventing scope creep while allowing valuable learnings from quick hacks.
Your example of consolidating multiple services onto a single VM underscores how real-world usage reveals what truly matters, often debunking assumptions made during planning. This iterative, low-cost experimentation can be invaluable for early-stage startups or projects with limited resources, enabling data-driven decisions before investing in complex architecture.
The hardcoded configuration strategy is also noteworthy. While it may seem unorthodox, it emphasizes agility and rapid iteration—key factors in early development phases. As you mentioned, tracking changes via git adds a layer of control, making it easier to revisit and refactor when appropriate.
Overall, your framework encourages a pragmatic, learning-oriented mindset that many teams can benefit from—focusing on real user needs over premature optimization. Thanks for sharing these practical insights!