The 3-Month Strategy: A Practical Approach to Unscalable Development
In the realm of startup development, Paul Graham’s famous advice to “do things that don’t scale” is often quoted but rarely mapped out into actionable steps. As a software engineer launching an AI podcast platform over the past eight months, I’ve created a straightforward framework: each unscalable solution is put to the test for three months. After this period, it either proves its worth and receives a proper build-out or is discarded.
In startup culture, there’s a tendency to prioritize scalable solutions, often rooted in the mindset of larger organizations. Concepts like microservices and intricate architectures designed to accommodate millions of users are compelling, but for early-stage startups, they can significantly delay product delivery. My three-month rule has pushed me to prioritize simple, functional code that actually gets deployed, allowing me to understand user needs without getting bogged down in unnecessary complexity.
My Current Strategies and Their Unexpected Benefits
- Consolidated Hosting on a Single VM
Everything—database, web server, background jobs, Redis—operates on a single virtual machine costing just $40 per month. While this setup boasts zero redundancy and requires manual backups, the insights I’ve gained far surpass the predictions from any capacity planning document. My platform, which I initially thought would be resource-heavy, only needs around 4GB of RAM. The complex Kubernetes architecture I contemplated would have been overkill for an empty use case.
- Hardcoded Configuration for Quick Adjustments
Configuration settings like pricing tiers and user limits are hardcoded and spread across my codebase. Admittedly, this requires redeploying to make changes, but it enables me to quickly search through my entire project. Git history neatly tracks adjustments, and each change is reviewed—even if it’s just by me. This has proven far more efficient than developing a dedicated configuration service, as my adjustment frequency has remained low.
- Utilizing SQLite in a Production Environment
My multi-user web app currently runs on SQLite, which has comfortably handled up to 50 concurrent users with a database size of just 47MB. This choice led to valuable insights, revealing that my access patterns favor reads over writes. Had I opted for a more complex system like Postgres from the start, I would have unnecessarily fixed issues that weren’t present.
- Direct Git Pushes to Production
Deployment is achieved with a single command: `
One Comment
This is a compelling and practical approach to early-stage startup development. I particularly appreciate how you’ve embraced “doing things that don’t scale” as a deliberate strategy—recognizing that rapid iteration and learning often trump perfect architecture in the beginning. Your three-month rule acts as a disciplined yet flexible framework to validate solutions before investing resource-heavy efforts.
The emphasis on simplicity—such as consolidating hosting, using hardcoded configs for quick adjustments, and employing SQLite—aligns well with the principle that early prototypes should prioritize speed and insight over robustness. Additionally, direct deployment methods like Git pushes can significantly cut down feedback cycles, empowering you to respond swiftly to user needs.
One potential area to consider as you evolve: as user demand grows, balancing the need for quick fixes with gradual improvements will become crucial. Perhaps establishing scalable pathways to adapt your environment—like modular migration strategies—can help smooth that transition without losing your original agility.
Overall, your framework beautifully illustrates a pragmatic mindset that can help other developers and founders get their MVPs off the ground efficiently while maintaining a clear path toward scalable solutions as the product matures. Thanks for sharing these insights!