Embracing the 3-Month Rule: A Pragmatic Approach to Unscalable Solutions
In the startup world, the well-known wisdom from Paul Graham—”Do things that don’t scale”—is often easier said than done, especially when it comes to coding. Over the past eight months of building my AI podcast platform, I’ve developed a strategic framework to navigate this challenge: the 3-Month Rule. Essentially, any temporary solution that doesn’t scale gets a three-month trial period. By the end of that timeframe, it either proves its worth for a more robust implementation or it gets phased out.
As software engineers, we are frequently conditioned to develop scalable architectures from the outset. We revel in intricate designs, from microservices to distributed systems, all intended to support countless users. However, this approach often leads to unnecessary complexity in a startup environment where scalable solutions can frequently serve as costly procrastination. My 3-Month Rule encourages me to write straightforward, even imperfect code that is deployable, allowing me to understand user needs more effectively.
My Current Infrastructure Hacks and the Wisdom Behind Them
1. Single VM Deployment
My entire stack—database, web server, background jobs, and caching—resides on a single $40/month virtual machine, with manual backups to my local drive. While this setup may seem reckless, it has provided invaluable insights into my actual resource consumption. Within two months, I discovered that my “AI-heavy” application peaks at just 4GB of RAM. Had I gone with a complex Kubernetes configuration, I would have ended up managing idle containers instead of dealing with real usage data.
2. Hardcoded Configuration
Instead of relying on external configuration files or environment variables, I have hardcoded constants throughout my code, such as:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
While it may seem unorthodox, this method enables me to quickly locate any configuration parameter via a codebase search. Changes require minimal redeployment time—around 15 minutes—compared to the weeks it would take to build a centralized configuration service.
3. SQLite as a Production Database
Running SQLite for my multi-user web app may raise eyebrows, but my entire database is a mere 47MB and efficiently supports 50 concurrent users. My traffic patterns revealed that
One Comment
This is a fantastic approach to balancing agility with practicality, especially in the early stages of a startup or project. The 3-Month Rule reminds us that shipping functional solutions quickly can provide invaluable real-world insights that layered, ‘perfect’ architectures might delay. Your examples—using a single VM, hardcoded configs, and SQLite—highlight how embracing simplicity can accelerate learning and iteration.
It’s worth noting that this mindset aligns well with the concept of *progressive complexity*, where systems evolve alongside user needs rather than anticipating all future demands upfront. By setting a clear timeline for evaluating whether unscalable solutions are worth investing in, you’re effectively reducing technical debt and avoiding premature optimization.
Have you considered periodically reassessing these “temporary” setups to ensure they still meet current needs? Sometimes what starts as a quick hack becomes an enduring part of the infrastructure, and structured reviews can help determine if future improvements are justified. Thanks for sharing this pragmatic framework—it’s a valuable reminder that doing things that don’t scale early on can be a strategic advantage!