Embracing the 3-Month Rule: A Pragmatic Approach to Non-Scalable Solutions
In the world of startups, the age-old wisdom from Paul Graham, advocating for “doing things that don’t scale,” is often referenced but rarely explored in terms of practical application. As a seasoned engineer developing an AI podcast platform over the past eight months, I have adopted a straightforward framework to embody this principle: I give each unscalable hack a trial period of three months. After this time, they either prove their worth and become part of the foundational architecture or are gracefully retired.
As engineers, we are typically conditioned to prioritize scalable solutions from the outset. Concepts like design patterns, microservices, and distributed systems dominate our training and focus on accommodating future demand. However, in a startup environment, this mindset may lead to costly delays, as we often find ourselves optimizing for hypothetical users and challenges rather than current realities. My 3-month rule encourages me to create straightforward, albeit imperfect, code that can be deployed quickly, while simultaneously providing insights into the genuine needs of my users.
Current Infrastructure Insights: My Strategic Hacks
1. All Services on a Single Virtual Machine
My setup consists of a database, web server, background jobs, and Redis—all operating on a single $40/month virtual machine. This lack of redundancy might seem imprudent, but here’s the upside: in just two months, I have gained valuable insights into my actual resource requirements. My platform, which I assumed was resource-intensive, only reaches a peak of 4GB RAM usage. The complex Kubernetes infrastructure I almost implemented would have unnecessarily complicated things, managing idle containers instead of addressing real-time performance.
When the system crashes (which has occurred twice), I gather genuine data on what fails—often surprises that I hadn’t anticipated.
2. Hardcoding Configurations
My configuration is notably simple:
plaintext
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
With hardcoded values throughout the codebase, any adjustments require a redeployment. While some may argue that this goes against best practices, my ability to quickly search the codebase for values provides an unexpected advantage. Each price change, tracked in git, ensures clarity. With just three configuration updates in three months, I easily save time by avoiding the lengthy setup of a configuration service.
**3
One Comment
Thank you for sharing this insightful approach. I really appreciate the emphasis on speed, learning, and validation through real-world data—especially in the early stages where assumptions can be misleading. The 3-month trial period is a practical way to balance agility with eventual scalability, avoiding paralysis by over-engineering.
Your example of consolidating everything onto a single VM highlights the value of simplicity in gaining initial insights. It’s a great reminder that sometimes less complexity accelerates learning and reduces unnecessary costs. Similarly, hardcoding configurations can be a double-edged sword, but your strategy of quick changes and clear version control strikes a good balance.
This framework could be especially valuable for early-stage startups or teams facing resource constraints. It encourages a mindset of experimentation, with clear checkpoints for reevaluation. Have you thought about adding a formal review process after each 3-month cycle to decide whether to iterate, refactor, or replace the solutions? That might help maintain momentum without sacrificing the flexibility you’ve built into your process.