Embracing the 3-Month Rule: A Practical Approach to Unscalable Solutions in Coding
In the entrepreneurial landscape, the renowned advice of Paul Graham resonates strongly: “Do things that don’t scale.” While many accept this principle, few discuss its application in the realm of software development. After dedicating eight months to building my AI podcast platform, I’ve established a straightforward framework that guides me through this process: each unscalable solution is given a timeframe of three months. At the end of this period, if it proves its worth, it will be built out properly; otherwise, it will be abandoned.
The reality for many engineers is that they are conditioned to create scalable solutions from the outset. This includes utilizing intricate design patterns, microservices, and distributed architectures—all designed to support thousands, if not millions, of users. Yet, such thinking is more suited to established organizations than startups, where scalable infrastructure can often distract from immediate needs and serve as mere delays in development.
In a startup context, I’ve discovered that writing simple, albeit non-ideal code is the key to understanding the real needs of my users. The three-month guidelines compel me to prioritize shipping over architectural perfection.
Current Infrastructure Choices: A Strategic Perspective
1. Consolidating Everything on a Single VM
Everything from the database to the web server and background jobs operates on a single virtual machine costing just $40 a month. Sure, it’s devoid of redundancy and relies on manual backups, but this setup has proved invaluable. Within just two months, I’ve gained critical insights into my actual resource utilization, discovering that my “AI-intensive” platform peaks at just 4GB of RAM. The elaborate Kubernetes setup I nearly implemented would have accounted for nothing more than empty containers.
Every time the system crashes—which has happened twice—I obtain valuable information about the specific breakdowns, often revealing unexpected insights.
2. Utilizing Hardcoded Configuration
I employ hardcoded constants for configurations, with no separate config files or environment specifications. This simplicity means direct access to configuration values across my codebase. Each price alteration is easily tracked through Git history, ensuring all changes are reviewed, albeit by myself.
Creating a configuration service would have consumed an entire week. Instead, I’ve made three changes in three months, equating to a mere 15 minutes of redeployment versus the daunting 40 hours of engineering time required for a more sophisticated system.
3. Running SQLite in Production
Surprisingly, my
