Embracing the 3-Month Rule: A Pragmatic Approach to Unscalable Solutions in Tech Development
In the world of startups, the advice from influential figures like Paul Graham often resonates profoundly: “Do things that don’t scale.” Yet, the challenge lies not in understanding this concept but in applying it effectively, especially in the realm of coding.
After dedicating eight months to developing my AI podcast platform, I’ve devised a straightforward yet powerful framework: any unscalable workaround is given a lifespan of just three months. At the end of this period, I assess its viability. If it proves beneficial, I invest in building a more robust solution; if not, it’s time to let it go.
As engineers, we are often conditioned to seek scalable solutions right from the start. Terms like design patterns, microservices, and distributed systems are commonly thrown around as we envision our creations catering to millions. However, this is the mentality of larger companies—at a startup, aiming for scalability prematurely can turn into an expensive form of procrastination. My three-month method encourages me to write straightforward, even “imperfect,” code that is quick to deploy, allowing me to better understand what my users genuinely require.
Current Technical Shortcuts: The Rationality Behind My Choices
1. Simplifying with a Single Virtual Machine
I’ve centralized everything—database, web server, background jobs, and caching—on a single $40/month virtual machine. While it lacks redundancy and relies on manual backups, this setup has illuminated my actual resource needs more effectively than any formal capacity planning report. My platform, which I initially described as “AI-heavy,” peaks at 4GB of RAM, proving that my nearly-constructed Kubernetes arrangement would have only been managing idle resources. When the server crashes (and it has twice), I gather crucial data about real points of failure, which are often surprising.
2. Using Hardcoded Configuration Values
Things like pricing tiers, user limits, and model specifications are hardcoded directly into my files. This approach eliminates complexities related to configuration files and environmental variables. Interestingly, the benefit of this simplicity is evident: I can search through my entire codebase in seconds to find any configuration value. Changes are infrequent—just three adjustments in three months—meaning a quick redeployment saves hours of engineering effort.
3. Running SQLite in Production
Yes, I’ve decided on SQLite for my multi-user web application, and it’s
One Comment
Thank you for sharing your practical framework—it’s a compelling reminder that sometimes, simplicity and agility outperform overly complex solutions, especially in the early stages of a startup. Your three-month review cycle fosters a disciplined approach to experimentation, minimizing sunk costs on unproductive work.
I particularly appreciate the emphasis on embracing “imperfect” code for rapid learning. This mindset aligns well with the idea that building a deeper understanding of user needs often requires quick iterations over perfect solutions.
Your choice of a minimal setup—such as using a single VM and SQLite—might seem risky from a traditional scalability perspective, but it exemplifies how real-world constraints can inform smarter engineering decisions early on. It’s about balancing immediate learnings with future scalability plans, not avoiding them altogether.
Would be interesting to hear how you handle transitioning from these unscalable solutions to more scalable architectures once your product gains traction—does the three-month rule continue to guide those decisions as complexity increases?