The 3-Month Experiment: A Practical Approach to Learning Through Unscalable Hacks
Paul Graham famously championed the idea of “doing things that don’t scale” in startups, but rarely do we discuss how to translate that wisdom into practical coding strategies. Over the past eight months of developing my AI podcast platform, I’ve established a straightforward framework: each unscalable solution gets a dedicated three-month trial. After this period, we assess whether it deserves a full-fledged approach or should be discarded.
As engineers, we often gravitate towards creating scalable solutions from the onset—envisioning architecture that supports millions of users, complete with design patterns and microservices. Yet, this approach is often more suited to established companies than to agile startups. In the early stages, focusing on scalability can lead to costly delays, as time is spent optimizing for hypothetical users and issues that may never arise. My three-month rule encourages me to embrace simple, direct, and sometimes considered ‘bad’ code that is deployable and illuminates the genuine needs of users.
Innovative Infrastructure Choices: Smart Hacks for Fast Learning
Here are some of my current infrastructure strategies and the rationale behind them:
1. Consolidated Operations on One Virtual Machine
I operate my database, web server, background jobs, and Redis all on a single $40/month virtual machine with no redundancy, relying on manual backups to my local drive. This decision has revealed valuable insights about my resource requirements within just two months, far surpassing what any theoretical capacity planning document could offer. For instance, my platform’s peak resource usage is only 4GB of RAM. The complex Kubernetes setup I almost implemented would have simply managed idle containers, leading to wasted resources.
Whenever the system crashes (which has happened twice), I glean practical data about the real points of failure—often unexpected ones.
2. Hardcoded Constants for Configuration Management
I’ve opted for hardcoded constants for settings such as pricing and user limits scattered across my code. While this might seem impractical, it allows me to quickly search for any value and track changes through Git history. Over three months, I’ve only modified these values three times, which took about 15 minutes to redeploy. In contrast, creating a configuration service would have required a week’s work.
3. SQLite in a Multi-User Environment
I’m currently using SQLite for my web app, which features a database size of only 47MB and comfortably supports up to 50 concurrent users.
One Comment
This framework of embracing unscalable hacks over a defined period offers a compelling balance between agility and informed decision-making. I appreciate how you’ve highlighted the importance of avoiding premature optimization and overengineering in the early startup stages. Your example of consolidating operations on a single VM serves as a practical reminder that real-world testing often reveals the most critical bottlenecks, which theoretical models may overlook.
Additionally, using hardcoded constants for configuration management can indeed save significant time—what matters most in the initial phases is rapid iteration and learning. Your approach demonstrates that sometimes, simplicity and speed outweigh complexity, especially when validated by real-world data.
I’m curious if you’ve encountered situations where a quick-and-dirty solution persisted longer than intended or eventually needed refactoring? Also, have you considered integrating a lightweight configuration management method for settings that are likely to change more frequently, to balance flexibility without overhauling your current speed-focused approach? Great insights—thanks for sharing!