Embracing the 3-Month Rule: A Pragmatic Approach to Unscalable Solutions in Tech
In the tech industry, the notion of doing things that don’t scale is often championed, particularly by voices like Paul Graham. Yet, there seems to be a gap when it comes to actionable steps that can be taken in coding practices. After dedicating eight months to the development of my AI podcast platform, I’ve crafted a practical framework that revolves around a three-month experimentation cycle. Each “unscalable” solution gets just three months to demonstrate its worth; if it can’t prove itself, it’s time to move on.
As engineers, we’re conditioned to pursue scalable solutions from the outset. We often gravitate toward advanced architecture techniques such as microservices, distributed systems, and design patterns that are meant to support millions of users. However, this kind of thinking can lead to excessive caution in startup environments, where the focus should instead be on immediate user needs.
In many cases, laying down scalable code turns into costly procrastination, optimizing for users who don’t yet exist. My three-month rule encourages a more straightforward, albeit imperfect, coding approach that allows for rapid deployment and genuine feedback on what users truly require.
Current Unconventional Strategies: The Pragmatic Choices Behind Them
1. Single Virtual Machine for Everything
I’ve centralized my database, web server, and background jobs onto a single $40/month virtual machine (VM). While this setup lacks redundancy and relies on manual backups, the insight gained has been invaluable. Within merely two months, I’ve gauged my actual resource utilization better than any theoretical analysis could have provided. Knowing that my AI-focused platform rarely maxes out at 4GB RAM saved me from investing in an unnecessary Kubernetes setup. Each time the system fails, I gather real-time data that highlights genuine weak points—often not the ones I anticipated.
2. Hardcoded Constants Throughout Code
Instead of utilizing configuration files or environment variables, I have hardcoded certain parameters directly into my code, like pricing tiers and user limits. While this may sound unorthodox, it has hidden advantages: I can quickly search my entire codebase for any value, and every minor change is easily tracked through version history. Over three months, I’ve only adjusted these constants three times, allowing me to save substantial engineering hours.
3. SQLite Serving as Production Database
Yes, SQLite is my production database for a web application that supports multiple users. Its compact
One Comment
This post offers a compelling perspective on balancing speed and practicality in early-stage development. The 3-month rule serves as a disciplined framework that encourages experimentation without getting bogged down by premature scalability concerns. I particularly appreciate the emphasis on real-world data over theoretical assumptions — like your use of a single VM to validate resource needs before investing heavily in infrastructure.
Hardcoding constants and using SQLite in production are bold choices that, while unorthodox, seem to align well with the philosophy of rapid iteration and learning. These strategies remind us that sometimes, “good enough” today fosters faster growth and more accurate feedback, which are critical in the initial phases of a product.
It might also be worth exploring how this approach scales once your use case matures; perhaps the insights gained here can inform thoughtful scalability plans down the line. Overall, a thoughtful, pragmatic approach that can save time and resources while honing in on actual user needs.