The Three-Month Principle: My Approach to Embracing Non-Scalable Solutions in Tech

In the world of startups and tech product development, the advice given by famed entrepreneur Paul Graham still resonates profoundly: “Do things that don’t scale.” Yet, how does one effectively apply this principle within the coding arena?

For the past eight months, I have been dedicated to crafting an AI podcast platform, and throughout this journey, I’ve constructed a straightforward framework: any hack that lacks scalability is granted precisely three months to demonstrate its value. Following this period, it either evolves into a well-structured solution or is discarded.

As software engineers, we often find ourselves conditioned to build scalable systems from the very outset. We dive into design patterns, conceive microservices, and create distributed architectures—strategies designed to cater to millions of potential users. However, such “big company” thinking can lead to wasted resources in a startup environment.

In reality, code designed for scalability can often be nothing more than an expensive way to procrastinate, focusing on hypothetical users while neglecting the immediate task at hand. My three-month rule compels me to create straightforward, albeit imperfect, code that is deployable and reveals genuine user needs.

Insights from My Current Infrastructure Techniques

1. Simplified Infrastructure: One Virtual Machine
Rather than creating a complex setup, I opted to run my database, web server, and background tasks on a single virtual machine for just $40 a month. While this approach lacks redundancy and relies on manual backup, it has provided me with invaluable insights about my resource requirements. Within just two months, I’ve recognized that my AI-centric platform typically peaks at 4GB of RAM—information that would have remained elusive with an overly complicated infrastructure.

2. Hard-Coded Configuration
Instead of adopting environment variables or configuration files, I consolidated my settings into constants directly within the code, encouraging a more straightforward deployment process. Although initially it may seem retrograde, this method allows me to quickly search for configuration values and ensures that all changes are documented through version control. With only three configuration changes in three months, the time saved from this ease of access far outweighs the effort to build a separate configuration management service.

3. Leveraging SQLite for Production
Admittedly, running SQLite on a multi-user application may raise eyebrows. However, with a mere 47MB database, it comfortably supports up to 50 concurrent users. This choice helped me realize that