The 3-Month Rule: A Pragmatic Approach to Early-Stage Development
In the tech community, Paul Graham’s guidance to “do things that don’t scale” is widely recognized. However, the challenge lies in effectively integrating this philosophy into software development. After eight months of building my AI podcast platform, I have crafted a straightforward method: each unscalable solution is granted a lifespan of three months. After this period, it’s either refined into a robust feature or phased out.
As engineers, we’re often trained to pursue scalable solutions right from the start—thinking in terms of design patterns, microservices, and distributed systems meant to support millions of users. This approach is commendable for larger enterprises, but for startups, focusing on scalability too early can be a form of procrastination, draining resources on hypothetical user problems. My three-month rule compels me to create straightforward code that provides tangible insights into user needs.
Current Infrastructure Practices: Smart Solutions in Action
1. Single VM Deployment
I run my entire infrastructure—a database, web server, background jobs, and Redis—on a single $40/month virtual machine, with no redundancy and manual backups.
Why is this approach effective? I’ve gained a clearer understanding of my resource demands in just two months than what typical capacity-planning documents would reveal. My platform’s peak usage is merely 4GB of RAM, proving that the complex Kubernetes setup I considered would have been unnecessary and counterproductive. When the system crashes, I gather firsthand data about failures, often revealing unexpected issues.
2. Hardcoded Constants for Configuration
I utilize hardcoded constants throughout my codebase, defining values like pricing tiers and maximum users directly into the source files.
This simplistic choice has its advantages. A quick search allows me to locate any configuration value in seconds, with git tracking all changes. In three months, I’ve only altered these constants three times, saving me significant engineering hours compared to building a dedicated configuration service. The time investment has been minimal, whereas the payoff involves streamlined deployment processes.
3. SQLite as a Production Database
For my multi-user web application, I opted to use SQLite, managing to run a 47MB database that efficiently handles 50 concurrent users.
This decision led to a significant discovery: 95% of my database interactions consist of reads rather than complex writes. If I had configured Postgres from the start, I would have unnecessarily focused on optimizing connection pools for a nonexistent issue. Now
One Comment
This post offers a refreshingly pragmatic take on balancing speed and scalability in early-stage development. The 3-month rule cleverly encourages rapid experimentation and learning, preventing paralysis by over-engineering. I particularly appreciate the emphasis on direct feedback loops—whether through deploying on a single VM or using SQLite—since these approaches provide authentic insights into user behavior and system limitations.
In my experience, embracing simplicity early on not only reduces technical debt but also fosters agility; teams can iterate faster and adapt based on real-world data. As you pointed out, hardcoded constants and minimal infrastructure not only save time but also clarify what truly impacts performance and user experience.
This methodology reminds me that the ultimate goal is to build a product that resonates with users first and foremost—scaling naturally from solid foundational insights rather than from assumptions or complex solutions prematurely. Looking forward to seeing how your platform evolves as you refine it beyond the initial three months!