The Three-Month Rule: A Pragmatic Approach to Non-Scalable Solutions
In the world of startup development, the mantra “do things that don’t scale” has become well-known, thanks to insights from industry leaders like Paul Graham. However, applying this principle, especially in coding, often remains uncharted territory for many entrepreneurs and engineers. After eight months of building my AI podcast platform, I devised a straightforward framework: every unscalable hack within my project is given a limited lifespan of three months. At the end of this period, I evaluate its effectiveness to decide whether to fully develop it or phase it out.
As engineers, we have been conditioned to prioritize scalability from the outset, embracing high-level design patterns and distributed systems that can accommodate vast user bases. Yet in a startup environment, pursuing scalable solutions too early often leads to costly delays. My three-month rule encourages me to prioritize simpler, more direct coding methods that enable real product shipping and, most importantly, provide essential insights into user needs.
Current Infrastructure Hacks and Their Advantages
1. Consolidation on a Single Virtual Machine
Currently, my entire setup—database, web server, background tasks, and Redis—resides on a single virtual machine costing $40 monthly. While this might seem risky, the lack of redundancy has yielded invaluable insights. Within two months, I gained a clearer understanding of my actual resource requirements, discovering that my “AI-heavy” application only peaks at 4GB of RAM. The complex Kubernetes infrastructure I almost adopted would have been over-engineered for this scenario.
When the system crashes—twice so far—I collect real-world data about the failures, far removed from my initial expectations.
2. Hardcoded Configuration Values
Instead of employing configuration files or environment variables, I use constants defined within the codebase:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
This straightforward approach simplifies updates, allowing me to quickly search for and modify configurations. While creating a dedicated configuration service might seem appealing, I’ve only needed to change these values three times in three months, conserving both time and resources.
3. Using SQLite in Production
Interestingly, my multi-user web application runs on SQLite, which has proven effective, managing about 50 concurrent users without issues. The key takeaway here is that my data access pattern
One Comment
Great insights on embracing the “three-month rule” as a pragmatic approach to balancing speed and scalability in early-stage development. I especially appreciate how you highlight the value of intentionally deploying quick, non-scalable solutions to gather real user data and avoid unnecessary complexity upfront.
This mindset aligns well with the concept of creating a *minimum viable system* that evolves based on actual needs—an approach that not only accelerates iteration but also reduces wasted effort. In my experience, the key is to set clear boundaries and review points, just as you’ve done, ensuring that temporary hacks don’t become permanent obstacles down the line.
One additional thought is to consider how documentation, even minimal, can aid in transitioning from these temporary solutions to more scalable ones once the product matures. Keeping a simple log of why certain hacks were introduced and when they are slated for review can streamline future refactoring efforts.
Thanks for sharing such a practical framework—it’s a valuable reminder that sometimes, the fastest path forward is to temporarily embrace non-scalability to learn, iterate, and then selectively invest in scalability based on validated needs.