Embracing the 3-Month Rule: A Technical Approach to Scalability at Startups

In the entrepreneurial landscape, many of us are familiar with Paul Graham’s mantra: “Do things that don’t scale.” However, the challenge often lies in translating this advice into practical applications within our coding projects. After eight months of developing my AI podcast platform, I’ve adopted a straightforward approach: each unscalable solution deserves a trial period of just three months. After that, it’s either validated and refined or discarded.

As engineers, we’re predominantly trained to create scalable architectures from the get-go, incorporating elegant design patterns, microservices, and distributed systems to accommodate millions of users. However, this mindset can lead to premature optimizations that hinder startup progress. Instead of focusing on hypothetical future users, my approach prioritizes immediate learning through simplicity.

Discovering Insights Through Infrastructure Hacks

1. Unified Server Infrastructure

To keep things straightforward, I run everything on a single virtual machine (VM) for just $40 a month, encompassing the database, web server, background jobs, and caching with Redis—all without redundancy. While this might seem reckless, it has taught me more about my resource needs in two months than any capacity planning document could. My platform’s peak usage requires only 4GB of RAM, making complex setups like Kubernetes unnecessary—especially since I would have spent time managing dormant containers.

When issues arise (which they have, a couple of times), I obtain valuable insights into what breaks—revealing unexpected vulnerabilities.

2. Hardcoded Configuration

My configuration values are hardcoded across the codebase, from pricing tiers to user limits. There’s no convoluted configuration management—just constants that are easy to track and manage. This methodology allows for rapid iteration: I can quickly locate any setting, and alterations are patiently documented in Git history. The time savings are substantial; making a change takes only minutes rather than hours of engineering effort.

3. Using SQLite in Production

Despite being a multi-user application, I run on SQLite with a database size of only 47MB, easily managing 50 users concurrently. This setup clarified my usage patterns: 95% of my interactions are read operations versus 5% writes, making SQLite an ideal choice. Had I opted for a heavier database like Postgres from the outset, I would have wasted time worrying about connection pooling and replication for a non-issue. Now, I have a clearer path to optimization before considering