Embracing the 3-Month Rule: A Pragmatic Approach to Unscalable Solutions in Tech
In the world of technology, renowned entrepreneur Paul Graham’s mantra resonates deeply: “Do things that don’t scale.” However, while the concept is well-understood, the methods to effectively implement it in the coding realm can be elusive. After spending the past eight months developing my AI podcast platform, I’ve created a straightforward framework: every unscalable hack is given a lifespan of three months. At the end of that period, it must either demonstrate its worth and be fully developed or be discarded altogether.
As software engineers, we are often conditioned to focus on scalable solutions right from the onset. We get enamored with concepts like design patterns, microservices, and distributed systems—architectures that promise to handle vast numbers of users efficiently. Yet, this is typically a mindset suited for large enterprises.
In the startup environment, however, focusing on scalability often turns into an exercise in delayed action and resource wastage. You’ll find yourself optimizing for hypothetical users and addressing issues that may never arise. My three-month rule compels me to embrace simpler, more straightforward code—what some might consider “bad”—that can be deployed quickly and provides valuable insights about user behavior.
Key Infrastructure Strategies That Are Surprisingly Savvy
1. Running Everything on a Single Virtual Machine
Currently, my entire stack—database, web server, background processes, and Redis—is hosted on a single $40 monthly virtual machine. This setup lacks redundancy, with backups executed manually on my local machine.
Why is this a wise choice rather than a flaw? After just two months, I’ve gained a far greater understanding of my actual resource requirements than any capacity planning document could offer. It turns out that my AI-focused platform only needs 4GB of RAM at peak usage. The intricate Kubernetes infrastructure I considered would have just led to managing empty containers.
When the server crashes (which it has a couple of times), I receive genuine insights regarding failures—spoiler alert: they are often not the issues I initially anticipated.
2. Utilizing Hardcoded Configurations
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
Gone are configuration files and environment variables; instead, I have constants embedded throughout the codebase. Changes necessitate a redeployment
One Comment
This is an insightful approach that echoes the importance of pragmatism and rapid iteration, especially in the early stages of product development. The 3-month rule reminds me of the concept of “getting to first value” quickly—focusing on prototypes that can be tested and validated without over-investing in scalability concerns that may not yet be relevant.
Your example of running everything on a single VM highlights a key point: true understanding of resource needs and failures often only come through direct experience, not hypothetical planning. Similarly, hardcoded configurations, while seemingly “bad practice,” accelerate deployment and reduce complexity during early testing phases, allowing faster feedback loops.
As startups grow, these unscalable solutions should be revisited—scaled thoughtfully or replaced—once the core product-market fit is validated. I appreciate how your framework balances immediate learnings with disciplined judgment about when to pivot toward more robust architectures.
Thanks for sharing this practical method; it encourages a mindset of deliberate, limited experimentation to avoid paralysis by overplanning.