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 familiar to many, but the implementation specifics—especially in coding—often remain elusive. After eight months of developing my AI podcast platform, I’ve adopted a straightforward framework that prioritizes simplicity and learning: I allow each unscalable solution a lifespan of just three months. At the end of that period, it either proves its worth and gets refined or gets retired.
As software engineers, we typically approach problems with an aim for scalability from the outset, embracing design patterns, microservices, and distributed systems. This inclination often reflects the mindsets prevalent in larger corporations. However, in the startup environment, focusing too much on scaling can lead to needless complications and delays. My three-month rule compels me to create straightforward, albeit imperfect, code that can be delivered quickly, ultimately revealing valuable insights about user needs.
My Current Infrastructure Approaches and Their Hidden Advantages
1. Unified Virtual Machine Setup
Currently, my entire platform—comprising the database, web server, and background jobs—operates on a single $40/month virtual machine without redundancies or complex outputs. While it may appear reckless, this setup has provided extremely valuable data about my actual resource requirements. In just two months, I discovered that my “heavy” AI platform operates comfortably within 4GB of RAM. The intricate Kubernetes architecture I almost developed would have resulted in managing underutilized containers. By experiencing real crashes (yes, twice!), I’ve gathered firsthand insights into the factors that truly affect performance, which were not what I initially anticipated.
2. Direct Configuration Management
In my code, you’ll find hardcoded configuration values—like pricing tiers and maximum user limits—rather than complex configuration services or environment variables. Although this might seem outdated, the efficiency is remarkable. I can quickly search through the entire codebase for any configuration value, allowing me to track changes through git history seamlessly. Over three months, I’ve made only a few adjustments, saving me countless hours on engineering by limiting redeployments to mere minutes.
3. SQLite for Production Use
I currently utilize SQLite to power a web application that supports multiple users, and it’s faring astonishingly well, with a compact database of just 47MB. This choice allows me to learn about my application’s access patterns—95% read requests versus 5% writes—perfectly suited
One Comment
Thank you for sharing your practical approach—it’s a refreshing reminder that sometimes simplicity and rapid iteration outperform over-engineering. The 3-month rule embodies a mindset that values learning through quick deployment and real-world feedback, which is especially crucial in startup environments where agility matters most. I find your experience with a single VM and hardcoded configs illustrative of how addressing immediate problems directly can yield surprisingly robust insights. Have you considered that this approach not only accelerates your learning but can also help you identify the true bottlenecks and scalability requirements before investing in complex infrastructure? Balancing this pragmatic experimentation with long-term scalability planning can create a robust foundation that evolves naturally rather than through premature optimization. Looking forward to hearing more about how your infrastructure matures over time!