Embracing the 3-Month Rule: A Pragmatic Approach to Non-Scalable Solutions in Software Development

In the realm of startup culture, one piece of wisdom stands out: “Do things that don’t scale.” This mantra, popularized by Paul Graham, often resonates with entrepreneurs and developers looking for innovative paths to grow their businesses. However, translating this advice into actionable strategies within engineering practices can be a challenge. Over the past eight months, while building an AI podcast platform, I’ve devised a straightforward framework that centers around a 3-month lifespan for each unscalable hack. After this period, each solution must either demonstrate its value and be transformed into a robust, scalable system or be discarded.

The startup Mindset: A Shift from Scalable Solutions

As engineers, we frequently approach problems with the mindset of building scalable solutions from the outset. We envision grand architectures involving microservices, distributed systems, and elaborate design patterns meant to accommodate millions of users. Yet, in a startup environment, investing too heavily in these scalable solutions can become an expensive form of procrastination. Often, we find ourselves optimizing for users that don’t yet exist while addressing issues that may never arise. By adhering to my 3-month rule, I’ve been compelled to write simpler, more direct code that can go live quickly, allowing me to better understand the actual needs of my users.

My Unconventional Infrastructure Hacks

Let’s delve into some of my current infrastructure strategies that may seem simplistic but have proven to be effective learning tools:

1. Consolidation on a Single VM

I currently run everything—database, web server, background jobs, and caching—all on one virtual machine costing $40 a month. This approach, admittedly lacking redundancy and relying on manual backups, has surprisingly provided me with invaluable insights into my resource requirements. I’ve learned, through some crashes, what truly breaks, which is often not what I anticipated.

2. Hardcoded Configurations

Within my code, configurations are directly embedded as constants, making deployment straightforward. While it might seem unorthodox to forego configuration files and environment variables, this strategy has proven efficient. I can quickly search my entire codebase for any value, and any changes made are documented in version control. The time saved from avoiding a complex configuration service—having only changed these values a few times—illustrates the benefits of this approach.

3. Using SQLite for Production

Instead of more complex database systems, I’ve opted