Embracing the 3-Month Rule: A Pragmatic Approach to Non-Scalable Solutions in Tech
In the world of startups and technological development, the wisdom of Paul Graham — “Do things that don’t scale” — is often parroted. But how do we, as developers, practically apply this principle in our work? After eight months of building my AI podcast platform, I’ve discovered a straightforward framework: every non-scalable hack has a lifespan of precisely three months. Beyond that timeline, it either proves its effectiveness and is developed into a full-fledged solution or it is discarded.
It’s crucial to recognize that our training as engineers typically emphasizes creating scalable solutions from the outset. We become adept at employing elegant design patterns, microservices, and distributed systems capable of servicing millions of users. While this architecture is impressive, it often mirrors the mindset of large corporations rather than the needs of agile startups.
At a startup, focusing too heavily on scalability can lead to unnecessary expenses and delays. We frequently find ourselves preemptively optimizing for users that may never materialize, addressing challenges that could be irrelevant. The essence of my three-month rule is to prioritize efficiency over perfection, enabling me to write simplified, albeit imperfect, code that gets deployed and reveals invaluable insights into actual user needs.
Current Infrastructure Hacks: Strategic Choices for Learning
1. Everything Runs on a Single VM
My entire setup — database, web server, background jobs, and Redis — operates on a single $40/month virtual machine. While this might seem risky due to the lack of redundancy and manual backups, it has been a game-changer. In just two months, I’ve gained insights about my resource needs that extensive planning would never have afforded me. For instance, I discovered that my “AI-heavy” platform consistently peaks at 4GB RAM. The complex Kubernetes architecture I nearly implemented would have resulted in managing underutilized containers. Each time the system crashes, which has happened twice, I receive concrete data about what actually fails, often contrary to my initial expectations.
2. Hardcoded Configuration Throughout
No configuration files or environment variables — just constants scattered across multiple files. While this might appear cumbersome, it yields significant advantages. With the ability to swiftly search my codebase for any configuration value, I can track changes in the git history easily. Every modification is accompanied by a redeployment, saving time in the long run; I’ve only adjusted these parameters three times in the past
One Comment
This post offers a refreshingly pragmatic perspective on balancing the need for quick iteration with strategic technical decisions. The 3-month rule is a strong heuristic—it encourages founders and engineers to avoid getting bogged down in over-engineering from the outset, emphasizing instead the importance of learning and validation through real-world use.
Your experience with a single VM and hardcoded configs underscores the value of simplicity and direct feedback loops, especially in early-stage environments. It reminds me of the concept of “simplify first, optimize later”—by embracing rough edges initially, you gain concrete insights that inform whether investing in more scalable infrastructure is genuinely necessary.
In my view, this approach aligns well with the startup mentality: prioritize speed, learn fast, and scale thoughtfully based on evidence rather than assumptions. Thanks for sharing this practical framework; it gives a tangible path for engineers navigating the tension between agility and scalability.