Embracing the 3-Month Rule: A Practical Approach to Non-Scalable Solutions in Tech
In the world of startups, speed and adaptability often trump perfection. The well-known advice from Paul Graham, “Do things that don’t scale,” is often mentioned but not deeply explored in the context of software development. After eight months of building my AI podcast platform, I’ve established a straightforward methodology that I call the “3-Month Rule.”
What is the 3-Month Rule?
The essence of my rule is simple: any unscalable solution I implement is given a trial period of three months. During this time, the focus is on learning rather than perfection. At the end of this period, I assess whether the hack has demonstrated its worth and should be transformed into a more robust solution or if it should be discarded entirely.
As engineers, we are usually inclined to design systems for scalability from the outset—implementing complex architectures like microservices and distributed systems in anticipation of significant user growth. However, in a startup environment, this mindset can lead to wasted resources and unnecessary complexity when your user base is still small. By adhering to my 3-month rule, I allow myself to write simpler, albeit “messy,” code that actually gets delivered, which reveals crucial insights about user needs.
Current Infrastructure Hacks: Thoughtful Innovations
Here are some of the unscalable hacks I’ve incorporated into my platform, and the valuable lessons I’ve gleaned from them:
1. Single Virtual Machine Setup
I run my entire system—a database, web server, background jobs, and caching—on a single $40-per-month virtual machine without redundancy. This may sound reckless, but it has provided a wealth of information about resource allocation. In just two months, I learned that my “AI-heavy” application peaks at 4GB of RAM, making an elaborate Kubernetes setup unnecessary.
When the server experiences crashes (which have occurred twice), I gain valuable insights into actual failure points—often locations I had not anticipated.
2. Hardcoded Configurations
Instead of utilizing configuration files or environment variables, all settings are defined as constants throughout the application. For example:
python
PRICE_TIER_1 = 9.99
MAX_USERS = 100
This approach might seem archaic, but it allows me to swiftly search the codebase for any variable, with every configuration change logged in git history. Throughout the past three months
One Comment
Thank you for sharing such a practical and insightful approach! The 3-Month Rule cleverly balances the need for speed and experimentation with disciplined evaluation. I particularly appreciate how it aligns with the ethos of “doing things that don’t scale,” especially in early-stage startups where agility is crucial.
Your emphasis on learning from unscalable hacks—like running everything on a single VM and hardcoded configs—illustrates that simplicity and rapid iteration often provide more valuable insights than over-engineering for future scale. These real-world tests enable data-driven decisions on what deserves robustification, saving time and resources in the long run.
This approach also highlights a broader principle: sometimes, the best way to understand system limitations and user needs is through direct, hands-on experimentation, even if the solutions are temporarily “messy.” Your framework could serve as a helpful blueprint for others navigating the tension between speed, learning, and eventual scaling. Looking forward to seeing how these insights evolve as you refine your platform!