Embracing the 3-Month Experimentation Rule: A Pragmatic Approach to Development

In the world of startup development, the advice from prominent figures like Paul Graham often inspires action: “Do things that don’t scale.” However, implementing this principle in actual coding practices is rarely discussed. After eight months of building my AI podcast platform, I have devised a simple yet effective framework: each unscalable solution receives a lifespan of three months. Through this process, we assess whether it deserves further investment or if it should be phased out.

The conventional mindset for engineers is to focus on creating scalable solutions right from the start. We tend to gravitate towards intricate design patterns, microservices, and distributed systems designed to manage millions of users—a mindset associated with larger corporations. However, in the startup environment, pursuing scalable code can often lead to costly delays. My three-month rule compels me to write straightforward and expedient code that yields actual results, helping me better understand user needs.

Current Infrastructure Strategies That Offer Unique Insights

1. Single VM Entity

I run my entire platform—database, web server, background jobs, and Redis—on a $40/month virtual machine. This approach does come with a lack of redundancy and requires manual backups to my local machine.

But here’s the brilliance: this setup has provided me more insight into my resource allocation in two months than any complex capacity planning document could have. My “AI-heavy” platform only utilizes about 4GB of RAM at peak. The extensive Kubernetes structure I nearly implemented would have merely been a management tool for empty containers. Each time the system crashes (twice so far), I gain invaluable data on failure points—information that often surprises me.

2. Hardcoded Configurations

In my code, configuration values like pricing tiers and user limits are hardcoded directly in the source files. This means any updates require a redeploy, but it offers a significant advantage: I can quickly locate any configuration value throughout the codebase. Tracking price changes is as simple as reviewing my git history—a process I have streamlined. I’ve made only three configuration changes in three months, saving me significant engineering hours.

3. Using SQLite in Production

Running SQLite for a multi-user web application may raise eyebrows, but my database size is a mere 47MB, and it manages 50 concurrent users seamlessly. This experience has taught me that my access patterns are predominantly read-heavy, which suits SQLite perfectly. Had I opted