The 3-Month Experiment: A Pragmatic Approach to Non-Scalable Coding
In the startup landscape, the wisdom of Paul Graham’s famous adage, “Do things that don’t scale,” often resonates deeply. However, the practical implementation of this strategy, particularly in coding, tends to be overlooked. After eight months of developing my AI podcast platform, I’ve devised an effective framework that allows me to embrace non-scalable solutions: every unscalable hack has a lifespan of three months. By the end of that period, a solution must either demonstrate its value and be refined or face elimination.
As engineers, we’re conditioned to construct scalable architectures right from the outset—think design patterns, microservices, and distributed systems crafted to accommodate millions of users. While that’s a noble pursuit, it often doesn’t suit the realities of startup life.
In the early stages, focusing on scalable solutions can be a costly diversion. It involves optimizing for users who may never materialize and tackling potential challenges that may never arise. My 3-Month Rule compels me to prioritize simple, straightforward, albeit sometimes “bad,” code that is deployable and reveals genuine user needs.
Current Innovations in My Infrastructure
1. Consolidation onto a Single VM
I’ve placed my database, web server, background jobs, and caching all on a single $40/month virtual machine with no redundancy—backups are done manually to my local machine. While this approach might seem reckless, it has provided invaluable insights. Within just two months, I’ve gained a clearer understanding of my resource requirements than any capacity planning document could offer. My platform’s maximum peak only utilizes 4GB of RAM, debunking the necessity for a complex Kubernetes setup that would have involved managing empty containers. When issues arise— as they have—I receive genuine feedback regarding failure points, often surprising me with insights that I hadn’t anticipated.
2. Hardcoded Configuration
Instead of relying on configuration files or environment variables, I integrate hardcoded constants directly into my code:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
While this may seem cumbersome, the benefit lies in simplicity and traceability. I can effortlessly search my codebase for any configuration value and track changes through Git history. Since I’ve only modified these values three times in three months,
One Comment
This is a refreshingly pragmatic approach that highlights the importance of experimentation and learning in early-stage development. The 3-Month Rule serves as a disciplined way to balance the risks of “bad code” against the need for rapid iteration and real-world feedback. I appreciate how you’ve emphasized that initial simplicity—consolidating onto a single VM, hardcoding configurations—can offer invaluable insights that often get lost in complex, scalable architectures too early.
Your framework aligns well with the idea that in the startup phase, the goal is to validate hypotheses quickly and adapt based on actual usage, rather than investing heavily in architecture that may never be necessary. It also reminds me of the concept that “working code is better than perfect code,” especially in the context of startups where speed is crucial.
One thought: as your platform grows, it could be beneficial to gradually introduce abstraction layers—like configuration management or modular components—once the core ideas and user needs are validated. But your approach provides a solid foundation for making data-driven decisions about when and how to scale. Thanks for sharing such an insightful methodology!