Embracing the 3-Month Rule: A Practical Approach to Non-Scalable Coding
In the tech world, Paul Graham’s mantra of “doing things that don’t scale” is well-known, but its application in coding often goes undiscussed. After dedicating eight months to developing my AI podcast platform, I’ve created a straightforward framework centered on a concept I’m calling the “3-Month Rule.” Essentially, I give each unscalable hack a trial period of three months. If it proves its worth, I invest in a robust solution; if not, it gets phased out.
As engineers, we are often conditioned to craft scalable solutions right from the starting block. With a focus on design patterns, microservices, and distributed systems, we aim to develop architectures that can accommodate millions of users. However, this perspective can lead to premature optimization at startups, where focusing on potential future needs may simply stall progress. My 3-Month Rule encourages the development of straightforward, albeit “imperfect,” code that can be deployed quickly, allowing me to truly understand user needs.
Insights from My Current Infrastructure Strategies
1. Centralized on a Single Virtual Machine
I operate everything—database, web server, background jobs, and even Redis—from a single $40-a-month VM. There’s no redundancy and backups are done manually to my local machine.
What seems reckless here has actually been quite illuminating. Within just two months, I gained valuable insights into my actual resource requirements—knowledge that far surpasses what a standard capacity-planning document could offer. For instance, my “AI-heavy” application only peaks at 4GB of RAM. The complex Kubernetes setup I once considered would have simply meant managing idle containers.
When the system experiences downtime (which has happened twice), I gain useful data on failure points, revealing unexpected vulnerabilities.
2. Configuration Hardcoding
Here’s the way I handle configurations:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
Instead of using config files or environment variables, I rely on constants that are scattered throughout my codebase. Adjusting a value necessitates redeployment, but this approach has a hidden advantage: I can search for any configuration with a simple grep command and track every price change in my git history. The time invested in forming a dedicated configuration service would have
One Comment
This post offers a compelling perspective on the practicalities of applying “doing things that don’t scale” to development, especially through the lens of the 3-Month Rule. I appreciate how it shifts the focus from theoretical scalability to immediate learning and iteration—core principles that resonate deeply with early-stage product development.
Your approach of deploying quick, unpolished solutions for a limited period allows for genuine user feedback and operational insights without overinvesting upfront. It also helps identify real bottlenecks and vulnerabilities that might be overlooked in overly complex architectures.
The decision to operate on a single VM and hardcode configurations is particularly insightful; it underscores that simplicity can drive quicker learning cycles. Once these foundational insights are solidified, scaling and optimization can follow more informed decisions.
Perhaps a valuable addition could be establishing a lightweight process to revisit and refactor these “non-scalable” code segments after the initial discovery phase—turning useful hacks into scalable solutions only when genuinely needed.
Thanks for sharing these practical strategies; they serve as a reminder that sometimes, less engineering complexity early on leads to more robust, user-centered products down the line.