Embracing the 3-Month Rule: A Pragmatic Approach to Non-Scalable Code
In the fast-paced world of startups, one piece of wisdom often echoes: “Do things that don’t scale.” Yet, amidst all the conversation around this advice, there is a noticeable gap in discussing how to translate it into actionable steps, particularly in the realm of programming.
Having spent the last eight months developing an AI podcast platform, I’ve adopted a straightforward strategy: each unscalable solution I implement receives a dedicated lifespan of just three months. After this period, it’s time to evaluate its worth—either it gets solidified with a proper infrastructure, or it gets discarded.
As engineers, we are often conditioned to chase scalable solutions right from the outset. Concepts like design patterns, microservices, and distributed systems become second nature, crafting frameworks that can potentially accommodate millions of users. However, this mindset tends to be more fitting for larger organizations, while in the startup environment, going big too soon can result in costly delays.
In essence, optimizing for potential users who don’t yet exist leads to unnecessary complications. My 3-month rule demands that I produce straightforward, less elegant code that is quick to deploy, enabling me to better understand what my users truly require.
Current Strategies: Embracing Simplicity for Insight
1. Unified Virtual Machine for Everything
Currently, I host my entire platform on a singular $40/month virtual machine that runs the database, web server, background jobs, and Redis without redundancy. Manual backups are a simple part of my workflow.
This approach, far from being a mistake, has provided invaluable insights about my actual resource consumption over just two months—far surpassing what any planning document could have offered. My AI-driven platform, contrary to expectations, only peaks at 4GB of RAM. The elaborate Kubernetes configuration I nearly pursued would have merely managed majority-empty containers.
When issues arise—and they have, on two occasions—I gain real experience from diagnostics, uncovering unexpected breakpoints.
2. Hardcoded Configurations
For settings like pricing tiers and maximum users, my strategy involves hardcoded constants woven throughout the codebase. The absence of configuration files or environment variables means that any change requires a redeployment.
The notable advantage here? It allows me to easily search my entire codebase, making it simple to track changes and discuss any modifications. In three months, I’ve only altered these constants three times, translating into a mere
One Comment
This is a compelling approach that highlights the importance of balancing rapid iteration with strategic simplicity, especially in the early stages of a startup. I appreciate how the 3-month rule effectively encourages us to prioritize quick learning and validation over premature investments in scalable infrastructure.
One valuable insight from your post is the emphasis on gaining real-world experience through straightforward setups—such as hosting everything on a single VM and hardcoding configurations—despite seeming informal or temporary. This practical experimentation enables faster feedback loops, helping to identify actual bottlenecks and user needs before committing to complex solutions.
It’s a reminder that “doing things that don’t scale” isn’t just about neglecting best practices but about intentionally focusing on agility and learning. Once the product’s core concept is validated, then investing in scalable architecture makes more sense.
Would love to hear your thoughts on how you plan to transition from these initial unscalable solutions to more robust systems once you reach that three-month threshold. How do you ensure that this process remains lightweight and flexible as the platform grows?