The 3-Month Rule: A Practical Approach to Unscalable Solutions
When it comes to the journey of creating a successful startup, many of us have heard the renowned advice from Paul Graham: “Do things that don’t scale.” However, very few delve deeper into how to effectively integrate this philosophy into our technical projects, especially in the realm of coding.
Over the past eight months, as I’ve been developing my AI podcast platform, I’ve created a straightforward framework that has completely transformed my approach: any unscalable temporary solution I implement is given a lifespan of just three months. At the end of that period, I evaluate its effectiveness to determine whether it deserves a long-term solution or if it should be discarded.
Typically, as engineers, we are conditioned to think about scalability from the outset. We focus on elegant architecture involving design patterns, microservices, and distributed systems to cater to potentially millions of users. However, this kind of thinking often leads to overengineering—especially at startups where focusing on non-existent user demands can amount to costly procrastination. My three-month rule encourages me to produce straightforward, perhaps rudimentary code that can be deployed quickly, teaching me valuable lessons about the real needs of my users.
My Current Infrastructure Hacks and Their Strategic Value
1. Everything Runs on a Single Virtual Machine
My entire stack—database, web server, background jobs, and Redis—is hosted on a single $40/month virtual machine. There is no redundancy, and I conduct manual backups to my local machine.
Why is this model effective? In just two months, I gained insights into my actual resource requirements that no capacity planning document could provide. I discovered that my platform’s peak usage only necessitates 4GB of RAM. The complex Kubernetes architecture I had initially contemplated would have led to managing empty containers instead.
Each time the system crashes (which has occurred twice so far), I receive real-world data regarding the specific points of failure, which often differs from my initial expectations.
2. Utilization of Hardcoded Configuration Values
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
I’ve opted for hardcoded constants rather than configuration files or environment variables. Modifying any value requires a redeployment.
The unexpected benefit? I can swiftly search my entire codebase for any configuration value within seconds. Each
One Comment
This post highlights a crucial mindset often overlooked in the pursuit of scalable, future-proof systems: embracing rapid, unscalable experiments to gain real user insights early on. I particularly appreciate the 3-month rule as a disciplined approach to iterate quickly without overengineering—it’s a pragmatic way to balance speed, learning, and resource management.
The example of running everything on a single VM is a compelling reminder that understanding actual usage patterns often requires stepping back from complex architectures. It echoes the “minimum viable infrastructure” philosophy, where simplicity enables faster iteration and more accurate real-world data. Also, the use of hardcoded configuration values, while seemingly rough, underscores how simplicity accelerates development and debugging in early stages.
This approach reminds me that technical decisions should be driven by immediate needs and validated through real-world feedback rather than assumptions. As startups grow, those unscalable hacks can be replaced with more scalable solutions, but only after they’ve provided clarity on what truly matters to users. Thanks for sharing this inspiring, practical framework!