Embracing Imperfection: My 3-Month Rule for Experimentation in Tech
In the realm of startup advice, Paul Graham’s saying, “Do things that don’t scale,” often echoes through discussions. However, there’s a significant gap when it comes to actionable strategies for applying this principle, especially in coding practices. After dedicating eight months to developing my AI podcast platform, I’ve crafted a simple yet effective framework: any unscalable solution I implement receives a three-month trial period. Following this timeframe, we evaluate its worth—either it evolves into a robust solution or it’s phased out.
Rethinking Scalability
In engineering circles, the conventional wisdom is to build for scalability from the outset. This approach often includes employing intricate design patterns, microservices, and sophisticated distributed systems—all designed to cater to a vast user base. However, when you’re running a startup, this mindset can lead to premature optimization, addressing theoretical issues that don’t apply yet. My three-month rule compels me to prioritize practicality over perfection, enabling me to write simpler, more direct code that actually gets deployed and allows for a deeper understanding of user needs.
Current Infrastructure Strategies: Smart Hacks
1. Unified Operations on a Single VM
I’ve consolidated all essential services—including the database, web server, background jobs, and Redis—onto a single $40/month virtual machine. There’s no redundancy, and backups are performed manually. While this setup might seem illogical, it has provided invaluable insights into real resource utilization. My AI-driven platform consistently peaks at just 4GB of RAM. I learned early on that my complex plans for a Kubernetes deployment would’ve only led to managing idle resources. Each crash serves as a lesson, revealing unexpected vulnerabilities.
2. Hardcoded Configurations
Configurations are hardcoded directly into my files, making adjustments a matter of redeploying the app. This might seem primitive; however, it allows for rapid tracking and auditing of changes through git history. In doing so, I’ve sacrificed hours of potential engineering work for a simple, efficient process. Over three months, I’ve only needed to alter configuration values three times—showcasing the time saved by this minimalist approach.
3. SQLite as a Production Database
I’m utilizing SQLite for my multi-user web application, and it’s performed flawlessly with a database size of just 47MB, accommodating up to 50 users simultaneously. This choice has helped me identify
One Comment
Thank you for sharing your practical approach to embracing imperfection and focusing on what truly matters in early-stage development. Your 3-month rule is a compelling framework—it balances the necessity of testing unscalable solutions with disciplined evaluation, preventing over-engineering too early. The simplicity of consolidating services on a single VM and hardcoding configurations aligns well with the principle of “doing things that don’t scale,” giving you immediate feedback and rapid iteration.
Your experience with SQLite for a small user base highlights an important point: foundational decisions should be driven by current needs, not future assumptions. It’s a good reminder that scalable infrastructure can be incrementally introduced as growth justifies it.
Overall, your approach advocates for a lean, flexible mindset that can adapt as your product evolves—an essential lesson for startups. Have you considered incorporating periodic review checkpoints beyond the initial three months to reassess once your user base expands? This might help in smoothly transitioning from minimal setups to more scalable architectures when the time comes.