Embracing the Unscalable: The 3-Month Rule for Building a Startup
In the startup world, we often hear the saying, “Do things that don’t scale,” a piece of wisdom from Paul Graham that reminds us of the importance of early experimentation. However, the challenge lies in applying this philosophy to coding practices effectively.
Having spent the last eight months developing an AI podcast platform, I’ve devised a straightforward framework: each unscalable approach or hack is given a lifespan of three months. After this period, it needs to either demonstrate its value and be transformed into a robust solution, or it faces elimination.
The Startup Mindset: Shift from Scalable to Immediate
As engineers, we typically focus on creating scalable systems from the outset—think microservices, distributed architectures, and sophisticated design patterns geared for millions of users. However, in the realm of startups, chasing scalability often amounts to delaying essential actions. It encourages us to optimize for non-existent users and tackle problems that we may never encounter. My three-month rule serves as a reminder to write straightforward, sometimes “messy,” code that prioritizes real-world user feedback and essential learning.
Current Hacks: A Practical Approach to Infrastructure
1. Unified Virtual Machine Infrastructure
All essential components of my application — from the database and web server to background processing and caching — currently reside on a single $40/month virtual machine. While this setup lacks redundancy and relies on manual backups, the insight I’ve gained has been invaluable. In just two months, I established my actual resource requirements. For instance, I discovered my “AI-intensive” platform operates efficiently with only 4GB of RAM, making overly complex solutions like Kubernetes unnecessary.
When errors occur, I receive genuine data on what breakdowns happen, often revealing surprises about system behavior.
2. Hardcoded Constants for Configuration
My configuration values are hardcoded within the codebase, such as:
python
PRICE_TIER_1 = 9.99
PRICE_TIER_2 = 19.99
MAX_USERS = 100
AI_MODEL = "gpt-4"
While some might argue for the necessity of dedicated config files, I find that using constants scattered throughout my code allows for swift tracking of changes via Git. Over the past three months, I’ve redeployed the system only a few times for updates, saving significant development time that would have been spent on more complex configuration management.
**3. SQLite
One Comment
This is an excellent and pragmatic approach to early-stage product development. Your 3-month rule effectively encourages agility and real-world feedback, which are vital in the startup environment. I appreciate how you’ve embraced “messy” or unscalable solutions initially—like a single VM, hardcoded configs, and simple databases—to rapidly learn and iterate. This mindset helps avoid the trap of over-engineering before validating core assumptions.
One additional insight is to systematically document the key learnings and performance bottlenecks identified during each 3-month cycle. This way, when the time comes to scale, you’ll have a clear roadmap of which components truly need robust solutions. Also, incorporating a regular review process at the end of each cycle can help you identify patterns and prioritize improvements effectively.
Overall, your framework exemplifies that in a startup, speed and learning often outweigh perfect scalability in the beginning. Looking forward to seeing how this approach evolves as your platform matures!