Embracing the 3-Month Rule: A Pragmatic Approach to Coding in Startups
In the tech world, the advice from Paul Graham to “do things that don’t scale” is a well-known mantra. However, the conversation often glosses over the practical implementation of this principle in the realm of coding. After spending eight months creating my AI podcast platform, I’ve devised a straightforward strategy: every unscalable workaround is given a lifespan of just three months. At the end of this period, each hack must either demonstrate its value and be properly integrated or be discarded.
Why Startups Need a Different Approach
As engineers, we are typically conditioned to design for scalability from the outset. Terms like design patterns, microservices, and distributed systems often dominate our thinking. While these concepts are invaluable, they primarily cater to the challenges faced by larger organizations. In a startup environment, focusing on scalability prematurely can lead to wasted resources, as you’re building solutions for users that might not even exist yet. By adhering to my three-month rule, I focus on producing straightforward code that prioritizes immediate user needs and allows me to learn quickly.
My Practical Infrastructure Strategies
Here are some of the unconventional methods I’m using right now, which I believe are quite effective:
1. Consolidated Operations on a Single VM
All my platform components—database, web server, background jobs, and Redis—operate on a single $40/month virtual machine. This means zero redundancy and manual backups to my local system.
What’s the rationale behind this? I’ve gained insight into my actual resource requirements in two months, far surpassing what any theoretical capacity planning could offer. It turns out my resource usage is far less complex than anticipated. When the VM crashes—and it has twice—I receive valuable data about the real failure points, which often surprise me.
2. Hardcoded Configurations
I store configuration values as simple constants in the codebase:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
No config files or environmental variables are used. When changes are necessary, redeployment is required.
The benefit of this approach? I can quickly search my entire codebase for any configuration value and maintain a change history in version control. This method has resulted in significant time savings, allowing me to focus on immediate adjustments rather than building out
One Comment
Thank you for sharing your practical take on the “do things that don’t scale” philosophy. Your three-month rule offers a refreshing balance between quick iteration and disciplined evaluation—a mindset vital for startups. I particularly appreciate your emphasis on learning from real-world failures, such as resource constraints and system crashes, which often reveal more than theoretical planning.
Your approach to infrastructure—consolidating on a single VM and using hardcoded configurations—prioritizes speed and simplicity, aligning well with MVP principles. While these methods may not be sustainable long-term, they facilitate rapid experimentation and learning. It’s interesting how this hands-on approach minimizes upfront complexity, allowing founders and engineers to focus on validating core assumptions before scaling.
One potential consideration is the transition plan beyond the initial three months—how do you envision evolving these setups as your platform grows? For instance, moving from hardcoded configs to environment variables or centralized configs might become necessary to maintain flexibility.
Overall, your strategy exemplifies pragmatic engineering—prioritizing immediate needs and learning, then scaling thoughtfully when it’s clear that certain solutions are worth formalizing. Looking forward to seeing how this approach continues to evolve as your project matures!