Embracing the 3-Month Rule: A Pragmatic Approach to Unscalable Engineering
In the world of startups, the advice from Paul Graham to “do things that don’t scale” often resonates deeply. However, the practical application of this philosophy can be a challenge, especially in the realm of coding. After eight months of developing my AI podcast platform, I’ve established a straightforward framework: every non-scalable solution is given a lifespan of three months. At the end of this period, it must either validate its worth through data or be discarded.
Traditionally, engineers are trained to create scalable solutions from the outset, focusing on intricate architectures designed to accommodate millions of users. While this approach is beneficial for larger companies, it can be counterproductive in a startup environment. In many cases, optimizing for an audience that doesn’t exist yet can lead to a waste of resources and time. My three-month rule encourages the creation of straightforward, rapid-code solutions that promote real user learning and feedback.
Current Infrastructure Strategies and Their Hidden Benefits
1. Centralized Operations on a Single VM
Instead of running multiple services on a complex infrastructure, I’ve opted for a single virtual machine that hosts everything—database, web server, background jobs, Redis—all for just $40 a month. While this setup lacks redundancy and relies on manual backups, it has allowed me to gauge my resource requirements more accurately than any form of capacity planning could provide. Surprisingly, the platform’s peak usage has only reached 4GB of RAM. I’ve gained invaluable insights from occasional crashes, which shed light on real weaknesses—often surprising ones.
2. Hardcoded Configurations
In my setup, configuration constants are embedded throughout the codebase—no config files or environment variables in sight. When I need to make changes, it requires a simple redeployment. This method seems simplistic, yet it has profound benefits; I can quickly search for any configuration value and track revisions through version control. The time saved is significant—just a few minutes of redeployment compared to various hours pursuing a complex configuration service.
3. Utilizing SQLite for a Multi-User Application
Yes, I’ve taken the unconventional route of using SQLite for my web application. With a mere 47MB database, it comfortably supports 50 concurrent users. This choice taught me that 95% of my access patterns are read-based, making SQLite a perfect fit. Had I opted for a more robust database like PostgreSQL from the beginning, I might
One Comment
This is a fantastic approach that highlights the value of rapid experimentation and learning in early-stage product development. Your 3-month rule effectively balances the need to iterate quickly with the discipline of data-driven decision-making, which can often be overlooked in startup environments. I especially appreciate the emphasis on simplicity—using a single VM, hardcoded configs, and SQLite—to reduce overhead and focus on understanding user behavior.
One insight to consider as your platform evolves is gradually introducing more flexible configuration management—perhaps via environment variables or external config files—once the core features are validated. This can help manage complexity without sacrificing the agility you’re advocating for. Also, while SQLite is excellent for initial phases, keep an eye on potential migration paths to relational databases that can support future scaling needs without disrupting your validated assumptions.
Overall, your framework exemplifies mindful resource use and a pragmatic mindset—key ingredients for sustainable growth in the unpredictable early days of a startup. Thanks for sharing such practical insights!