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
