Embracing the 3-Month Rule: A Pragmatic Approach to Unscalable Solutions in Software Development
In the world of software development, one piece of advice often rings true—especially for startups: “Do things that don’t scale.” While this wisdom, famously championed by Paul Graham, is well-known, its practical application in coding is often overlooked. During my journey of building an AI podcast platform over the past eight months, I’ve devised a straightforward framework: any temporary hack or workaround I implement gets just three months to prove its worth. After that period, it either transitions into a refined solution or fades away.
As engineers, our training typically emphasizes crafting scalable solutions from the outset—considerations like design patterns, microservices, and distributed systems are crucial for supporting massive user bases. However, in the startup landscape, striving for scalability too early can often lead to wasted resources and time, optimizing for potential users that may not even materialize. My three-month rule encourages me to write straightforward, albeit imperfect, code that solves immediate problems and reveals valuable insights into user needs.
Current Infrastructure Hacks: Smart Simplifications
Let’s delve into some unconventional decisions I’ve made regarding infrastructure and why they’re actually beneficial.
1. Consolidation on a Single VM
I’ve chosen to run my database, web server, background jobs, and caching on a single $40-a-month virtual machine, with no redundancy and manual backups. This may seem risky, but it has provided immense learning opportunities. Within just two months, I’ve gained firsthand knowledge of my actual resource requirements, realizing my platform only peaks at 4GB of RAM. The complex Kubernetes setup I almost implemented would have merely managed empty containers. When my system crashes (which has happened a couple of times), I gain concrete data on actual failures—turns out it’s rarely what I initially anticipated.
2. Hardcoded Configuration
Instead of implementing external configuration files or environment variables, I’ve adopted a hardcoded approach for settings like price tiers and user limits throughout my code. Yes, redeploying is necessary to make any changes, but this constraint allows me to quickly locate and track configuration values across my codebase. Over the past three months, I’ve adjusted these settings just three times, saving substantial engineering hours that would have been spent building a configuration service.
3. Utilizing SQLite in Production
For my multi-user application, I’m leveraging SQLite, boasting a compact 47MB database that effortlessly handles
One Comment
Great insights! I appreciate how your 3-month rule creates a disciplined approach to experimenting with unscalable solutions, allowing rapid validation without overcommitting resources early on. Your example of consolidating on a single VM highlights the value of firsthand experience over theoretical planning—sometimes simplicity provides the clearest data.
The hardcoded configurations may seem counterintuitive at first, but for rapid prototyping, they save time and keep the focus on solving core problems. It’s a good reminder that “perfect” infrastructure isn’t always necessary in the early stages—shipping quickly and iterating based on real user behavior often beats over-engineering from the start.
Using SQLite in production is an interesting choice as well—it’s a testament to how understanding the actual needs and constraints of your application can challenge conventional wisdom. As your platform grows, you’ll naturally identify when and where to scale or pivot, but your approach emphasizes learning and adaptation over premature optimization.
Looking forward, I’d suggest keeping an eye on how these hacks scale with your user base, and adapt your strategies as real-world data drives decisions. Thanks for sharing such a practical framework—definitely a valuable addition to the “do things that don’t scale” mindset!