The 3-Month Rule: A Pragmatic Approach to Non-Scalable Development
In the world of tech startups, traditional wisdom often emphasizes the importance of scalability. Paul Graham famously advocates for “doing things that don’t scale,” yet implementing this advice, particularly in coding, isn╬ô├ç├ût frequently discussed. After eight months of building my AI podcast platform, I╬ô├ç├ûve found a simple yet effective approach: any non-scalable hack gets a dedicated lifespan of three months. At the end of that period, if it proves its worth, it╬ô├ç├ûs built out; if not, it╬ô├ç├ûs phased out.
As software engineers, we’re trained to construct “scalable” solutions from the onset. This entails creating intricate architectures like microservices and distributed systems aimed at supporting vast user bases. However, in the startup realm, investing energy into scalability can often be a form of expensive procrastination╬ô├ç├╢focusing on future users and problems that may never materialize. By adhering to my 3-month rule, I╬ô├ç├ûm encouraged to write straightforward, unrefined code that can be deployed immediately, revealing the genuine needs of my users.
My Current Infrastructure Hacks and Their Hidden Benefits
1. Single VM Architecture
I currently operate all components╬ô├ç├╢database, web server, background jobs, and caching╬ô├ç├╢on a single $40/month virtual machine (VM) without redundancy and manually back up data to my local drive. This might sound risky, but the insights I╬ô├ç├ûve gained in just two months have been invaluable. I╬ô├ç├ûve discovered my resource requirements firsthand, which was far more informative than any theoretical capacity planning report. The result? My “AI-intensive” platform peaks at a mere 4GB of RAM, rendering plans for a complex Kubernetes setup unnecessary.
2. Hardcoded Configuration
Instead of employing configuration files or environment variables, I utilize hardcoded constants throughout my codebase. Updating a configuration necessitates redeployment, but this method provides its own advantages. It allows for rapid searching across files, tracking changes in Git history, and conducting quick code reviews. Since IΓÇÖve adjusted configuration values only three times in three months, this approach saves weeks of engineering effort.
3. SQLite as a Production Solution
IΓÇÖve opted to run a SQLite database for my multi-user web application, which currently sits at a compact 47MB and easily accommodates 50 concurrent users. This decision has helped clarify my access patterns, revealing predominantly read operations. Had I initially chosen Postgres, I would have wasted time optimizing
2 Comments
Thank you for sharing your practical approach to the 3-month ruleΓÇöitΓÇÖs a refreshing reminder that rapid experimentation and learning often outweigh theoretical perfection in the early stages. Your emphasis on leaning into simple, immediate solutions like single VMs, hardcoded configurations, and SQLite highlights how valuable firsthand insights can be before committing to scalable architectures.
This mindset aligns closely with the concept of ΓÇ£learning by doing,ΓÇ¥ where quick deployments reveal actual user behaviors and system requirements that abstract planning may overlook. It also underscores the importance of deliberately assessing each hackΓÇÖs value within a bounded timeframeΓÇöallowing teams to avoid unnecessary complexity and focus resources where theyΓÇÖre genuinely needed.
IΓÇÖd be interested to hear how you manage the transition once a hack proves its value beyond three monthsΓÇödo you have a structured process for refactoring or scaling up, or do you prefer to keep iterations lightweight? Overall, this pragmatic approach seems like a highly effective way for startups to maintain agility while staying responsive to real user needs.
This post brilliantly highlights the value of Fast Iteration and Learning over premature optimization, especially in the startup context. Embracing simple, non-scalable solutions early on aligns well with the Lean Startup methodologyΓÇöfocusing on validating assumptions quickly rather than over-engineering from the start. The 3-month rule acts as a disciplined scaffolding, preventing decision paralysis and encouraging rapid experimentation.
Your choice of infrastructureΓÇösingle VM, hardcoded configs, SQLiteΓÇöreminds me of the importance of reducing cognitive load and technical debt in early stages. ItΓÇÖs interesting how such pragmatic ΓÇ£hackyΓÇ¥ approaches can lead to more informed decisions when the real user data and application needs emerge, rather than relying solely on theoretical architecture.
This also underscores a key principle: optimize for learning, not for scale initially. Once your product gains traction and the actual needs are validated, then you can invest in scalable, maintainable solutions. Your approach exemplifies a mindful balanceΓÇötest ideas quickly, learn fast, and iterate effectively.