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
One Comment
This is a compelling perspective that highlights the value of embracing unscalable solutions as a means of gaining practical insights quickly. I appreciate how the 3-month rule encourages experimentation and learning without getting bogged down in premature optimization—a mindset especially vital for startups where adaptability is key.
Your example of using a single VM to run the entire platform underscores the importance of simplicity and direct feedback in infrastructure choices. It reminds me of the concept of “minimum viable architecture,” where a lean setup can illuminate real bottlenecks that abstracted or overly complex systems might obscure.
Similarly, hardcoded configurations, while usually discouraged in large-scale systems, serve as an invaluable quick-access tool during early development phases, especially when changes are infrequent. It’s a pragmatic approach that can save significant time and help maintain clarity.
Lastly, your use of SQLite in production resonates with the idea that the right tool depends on the specific context. Managing a small, read-heavy workload efficiently with SQLite demonstrates how tailoring solutions to actual usage patterns yields better resource utilization.
Overall, your framework encourages a disciplined yet flexible approach to development—prioritizing learning and iteration over dogmatic adherence to best practices. It’s a refreshing reminder that sometimes, “doing things that don’t scale” can be the fastest path to understanding what truly works in a given scenario.