Embracing the 3-Month Rule: A Pragmatic Approach to Temporary Solutions in Tech Development
In the realm of tech entrepreneurship, we often hear the sage advice of Paul Graham: “Do things that don’t scale.” While this principle is widely accepted, the intricacies of applying it within the coding process remain largely unaddressed.
After eight months of developing my AI podcast platform, I’ve established a straightforward framework inspired by this concept: each unscalable expedient is given a lifespan of three months. At the end of this period, we evaluate its effectiveness—if it demonstrates value, we commit to refining it; if not, it’s discarded.
The Challenge of Scalability in Startups
As engineers, there’s a natural inclination to focus on scalability from the outset. We envision grand architectures involving microservices or distributed systems, aiming for solutions that cater to millions of potential users. However, this “big company” mindset can become a trap for startups. Investing time and resources into scalable solutions often leads to what I like to refer to as “expensive procrastination.”
The reality is that many of us are prematurely optimizing for challenges that may never arise, as we’re typically focused on users who haven’t yet come into the fold. My three-month rule encourages me to deploy direct, albeit “imperfect,” code that generates real user feedback, ultimately informing my understanding of their needs.
Streamlined Strategies: My Current Temporary Solutions
- Single-VM Setup
My entire infrastructure—encompassing the database, web server, and background jobs—operates on a single, cost-effective $40/month virtual machine. Although this approach lacks redundancy and relies on manual backups, it has proven its worth through invaluable insights. I’ve gained a more accurate understanding of my platform’s resource demands in just two months than any capacity planning document could offer.
When the system experiences failures—something that has occurred a couple of times—I receive tangible data about what truly malfunctions. Surprisingly, the breakdowns are rarely what I initially anticipated.
- Inline Configuration Constants
Instead of employing configuration files or environment variables, I’ve opted for hardcoded constants throughout my code. This simplistic approach allows me to track price adjustments and configuration changes flawlessly. Each alteration entails a swift redeployment, saving an enormous amount of engineering time.
Compiling a configuration service would be an unnecessary endeavor, especially considering that I’ve changed these values merely three times in the past
