Embracing the 3-Month Rule: A Practical Approach to Unscalable Solutions in Tech
In the ever-evolving world of technology, the mantra of “doing things that don’t scale,” famously advocated by Paul Graham, is widely recognized. However, the specific methodologies for actualizing this philosophy in the realm of coding often go undiscussed.
After eight months of developing my AI podcast platform, I’ve formulated a pragmatic approach: I give every unscalable workaround a lifespan of just three months. Following this period, the solution must either demonstrate its worth and evolve into a robust system, or it will be discarded.
Why the 3-Month Rule Matters
As engineers, we are often taught to focus on “scalable” solutions from the outset—utilizing design patterns, microservices, and complex architectures that are designed to accommodate millions of users. However, this mindset is more suited to large corporations than to startups. In smaller ventures, investing time in scalability too early is typically a form of procrastination, as it revolves around hypothetical users and problems that may never arise.
This three-month rule encourages me to create straightforward, even “imperfect,” code that can be deployed swiftly. It allows me to gain firsthand insights into what users genuinely require.
Ingenious Infrastructure Hacks Worth Exploring
1. Single VM Operations
By operating my database, web server, background jobs, and other components on a single $40/month virtual machine (VM), I embrace a minimalist approach that lacks redundancy and relies on manual backups to my local system.
Rationale: In just two months, I’ve garnered more insight into my resource requirements than I could have through any complex capacity planning. The truth? My AI-centric platform’s peak usage only requires 4GB of RAM. The intricate Kubernetes setup I nearly implemented would have meant managing idle containers.
When my system crashes—twice so far—I receive meaningful data about the actual issues. Surprisingly, they seldom align with my expectations.
2. Hardcoded Configuration Values
Within my codebase, configurations such as pricing tiers and user limits are hardcoded directly into the software, eliminating the need for separate configuration files.
Benefits: This method allows me to search my entire codebase for any configuration value in mere seconds. Each price alteration is meticulously tracked in my version history, and every update is self-reviewed. Creating a dedicated configuration service could have taken a week, but I’ve only changed these
One Comment
This post offers a refreshing perspective on balancing agility and practicality in early-stage development. The 3-month rule strikes me as a disciplined way to avoid the trap of over-engineering, allowing startups to rapidly validate assumptions and adapt based on real user feedback. I appreciate how this approach emphasizes learning through minimal viable setups—like single VM operations and hardcoded configs—which provide direct insight into actual resource needs and user behavior.
One point to consider is the importance of documented boundaries when using unscalable solutions. For example, while hardcoded configurations accelerate initial iterations, having a clear plan to transition to more flexible setups as the project scales can prevent technical debt. Similarly, even simple backup strategies on a single VM are invaluable during rapid experimentation phases but should evolve to more robust solutions when user base and data complexity increase.
Overall, this methodology reinforces the value of intentional constraints that foster focused learning, with a mindful eye toward eventual scalability. It’s a reminder that, in the early days, speed and adaptability often triumph over perfect architecture—yet with a strategic eye on the future.