The 3-Month Rule: A Pragmatic Framework for Learning Through Unscalable Techniques
In the world of startups, the notion of “doing things that don’t scale,” as popularized by Paul Graham, resonates particularly well. However, implementing this principle effectively in a technical context is often overlooked. After dedicating 8 months to developing my AI podcasting platform, I’ve discovered a straightforward yet effective strategy: each unscalable approach receives exactly three months of experimentation. If it demonstrates its worth, it earns a permanent place in my architecture; if not, it’s discarded.
As engineers, we typically aim for scalability from the outset, crafting sophisticated systems designed for extensive user bases. However, this large-scale mindset can lead to unnecessary complexities for startups, where pursuing scalability too early often amounts to costly procrastination. By adopting my 3-month rule, I am compelled to embrace straightforward, albeit imperfect, coding practices that prioritize learning and user feedback.
Current Infrastructure Implementations: Smart Hacks that Work
1. Single-VM Hosting
I have opted to run my entire stack—database, web server, background jobs, and caching—on a single $40/month virtual machine. This means no redundancy and backups are handled manually. This choice revealed critical insights into my actual requirements. For instance, I discovered that my platform only needs 4GB of RAM during peak usage, which would have been obscured by a more elaborate setup like Kubernetes. Each crash provided valuable data on failure points, which were often surprising.
2. Hardcoded Configuration Values
My configuration management consists of constants directly embedded in my code:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
There are no separate configuration files or environment variables. While this method entails redeploying upon changes, it allows for rapid searches across my codebase, facilitating easy tracking of modifications. In the past three months, I’ve only modified these constants a handful of times, saving significant engineering hours.
3. SQLite in a Multi-User Environment
I’ve made the unusual choice to utilize SQLite for what could be deemed a more complex multi-user web application. Surprisingly, my database size is only 47MB, yet it effortlessly supports 50 concurrent users. This has allowed me to gauge access patterns—predominantly read operations—before considering more
One Comment
This post offers a compelling perspective on balancing experimentation and practicality in early-stage development. The 3-month rule provides a disciplined yet flexible framework that encourages quick validation without the paralysis often caused by over-engineering. I especially appreciate the emphasis on embracing “imperfect” solutions like single-VM hosting and hardcoded configs—these choices prioritize learning and speed over premature optimization.
From a broader perspective, this approach aligns well with the “build, measure, learn” philosophy, ensuring that each unscalable technique is given a fair trial period to demonstrate its value. It also highlights that effective engineering isn’t always about adopting the latest scalable tech from day one but rather about understanding your actual needs and iteratively refining your architecture based on real-world feedback.
Looking ahead, it might be interesting to compare how this 3-month validation period adapts as your platform grows and how you balance such quick experiments with the need for robustness in production. Nonetheless, this pragmatic methodology could serve as a valuable blueprint for startups aiming to stay agile and avoid unnecessary complexity early on.