Embracing the Three-Month Rule: A Practical Approach to Development at Startups

In the world of startups, where innovation often needs to outpace perfection, the advice from Paul Graham to “do things that don’t scale” is frequently echoed but seldom explored in a coding context. After eight months of nurturing my AI podcast platform, I’ve adopted a straightforward yet effective method: every unscalable hack I implement gets a trial period of just three months. At the end of this timeframe, each hack either proves its worth and transitions to a more robust solution or gets phased out.

As engineers, we often get caught up in the allure of crafting scalable architectures, employing design patterns and microservices that are impressive but may not align with the immediate needs of a startup ecosystem. The reality is that in a fledgling company, building scalable solutions can often delay progress and lead to wasted resources. My three-month rule compels me to create straightforward, often “messy” code that can be deployed quickly while also providing valuable insights into user needs.

Current Infrastructure Insights

Here are some of the unconventional strategies I’ve implemented that have yielded surprising benefits:

1. Consolidation on One VM

All critical functions—database management, web serving, background tasks, and caching—reside on a single, economical $40/month virtual machine. This setup offers no redundancy, and I maintain backups on my local machine.

Why is this approach advantageous? In the two months since implementing it, I’ve gained a clearer understanding of my actual resource requirements than through any formal capacity planning documentation. I’ve discovered that my platform’s peak memory use is merely 4GB. The complex Kubernetes architecture I considered would have merely required me to manage non-essential components.

When my server crashes (which has happened a couple of times), I gather authentic data regarding failure points—often contrary to my expectations.

2. Hardcoded Configuration Management

My configuration is scattered throughout the code, with constants defined directly in the files:

python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"

There are no external config files or environment variables. Any modifications require redeploying the application.

The unexpected benefit? I can quickly search my entire codebase for configuration values. Each price update is versioned in Git, and changes are self-reviewed. Designing a dedicated configuration service could take an entire