The 3-Month Experiment: A Framework for Embracing Unscalable Solutions
In the entrepreneurial landscape, startup founders often hear Paul Graham’s widely recognized mantra: “Do things that don’t scale.” While this advice is invaluable, there’s often little guidance on how to practically implement this in the realm of coding and development. After spending eight months constructing my AI podcast platform, I’ve devised a simple yet effective framework: every unscalable tactic is assigned a lifespan of three months. At the end of this period, it either reveals its worth and is transformed into a robust solution or it’s phased out.
A Shift in Mindset
As engineers, we are conditioned to design systems with scalability in mind from the outset. We tend to focus on sophisticated architectures like microservices, distributed systems, and other scalable solutions intended to accommodate millions of users. However, for a startup, this approach may turn out to be an expensive exercise in procrastination—one that prioritizes hypothetical users over actual needs. My three-month rule encourages me to create straightforward, albeit “imperfect,” code that can be deployed quickly, allowing me to gain real insights into what my users require.
My Current Approaches: Practical Choices with Purpose
1. Consolidated Infrastructure on a Single VM
Hosting my database, web server, background jobs, and Redis on a single $40/month virtual machine might seem reckless, but it has been incredibly instructive. With no redundancy and manual backups to my local drive, I have gained unparalleled insight into my actual resource requirements. I discovered that my platform, which I assumed would be resource-intensive, only peaks at 4GB of RAM. The complex Kubernetes set-up I nearly implemented would have only managed idle containers. Plus, each crash has provided valuable information about the real issues at hand.
2. Hardcoded Configurations
Rather than employing separate configuration files or environment variables, I have opted for hardcoded constants throughout my codebase. This approach makes accessing any configuration value quick and easy, drastically reducing the time spent on redeployments when changes are needed. Over three months, I’ve altered configurations just three times, highlighting the efficiency of my current strategy.
3. Using SQLite for a Multi-User Application
Despite the common belief that SQLite shouldn’t be used for web applications with multiple users, my 47MB database supports up to 50 concurrent users effortlessly. This setup has revealed my access patterns—95% reads and only
One Comment
This is a compelling approach that challenges the traditional emphasis on building scalable systems from the start. I appreciate how the 3-month rule creates a disciplined cycle for testing unscalable solutions, gaining real-world insights, and iterating quickly. It reminds me of the concept of *progressive disclosure*—starting with simple, imperfect solutions and evolving them based on actual user data rather than assumptions. Additionally, your experience with consolidating infrastructure and using SQLite highlights an important principle: **measure what you need to serve your current scale, rather than over-engineering early on**. This pragmatic mindset allows startups to focus resources on validated needs rather than hypothetical scalability. It would be interesting to explore how this framework can be adapted for teams with different risk tolerances or longer-term growth plans, ensuring that the initial unsophisticated solutions can evolve smoothly into scalable architectures When the time is right.