❯ Capacity Planning for a Solo Founder: Stop Guessing, Ship More

by Jonas Reyes — the builder's desk, Side Quest Studios
October 31, 2026

Alright, let’s talk capacity planning for a one-person shop. Because if you’re still thinking AWS is gonna hit a trillion dollars before you launch your next feature, you’re doing it wrong. AWS will be a $1T business, Jassy says — but first, it will spend big is a headline for them, not for us. We’re not spending big. We’re spending smart, and more importantly, we’re shipping. Your biggest capacity problem isn’t your server; it’s your brain. Your second biggest is the time you waste guessing.

I’ve seen enough people get paralyzed by "what if" scenarios to last a lifetime. They want to architect for a million users when they have zero. They’re optimizing database sharding when sqlite would handle their entire first year. This isn't capacity planning; it’s an expensive form of procrastination. We're here to build, deploy, and iterate. If you’re a solo founder, your capacity planning strategy is simple: measure, react, and automate. Anything else is overhead you can't afford.

Ditch the Crystal Ball, Start with top

Forget the fancy spreadsheets and vendor-pitched "AI-powered predictive analytics." Your first capacity plan is top (or htop if you like colors and graphs). Log into your server, run it, and see what's happening. Is your CPU pegged? Is RAM maxed out? No? Good. You have capacity.

When you're starting, your biggest constraint is not compute power; it’s your ability to deliver value. So, pick a small, cheap VPS. I'm talking a 1 CPU, 2GB RAM box for under $10/month. DigitalOcean, Linode, Vultr – doesn't matter. Just pick one and ssh into it.

Your stack should be lean. Python for the backend, Flask or FastAPI because they don't get in your way. PostgreSQL for serious data, SQLite for simpler stuff. Nginx as a reverse proxy, Gunicorn to run your Python app. That’s it. That’s your infrastructure.

Don't over-engineer. Don't worry about Kubernetes. Don't think about serverless until you actually need it. The overhead of managing that complexity will kill your velocity long before your users do.

Your First Threshold: iostat and free -h

Okay, so you’ve got some users. Maybe a few hundred, maybe a thousand. You’re starting to feel something. Your site feels a little sluggish. Don’t panic. Don't click the "upgrade instance" button yet.

First, identify the bottleneck. It's almost never what you think it is.

  • CPU: top will tell you if your CPU is busy. Look at the id percentage. If it's consistently low (e.g., < 20-30% idle), your CPU might be a constraint.
  • Memory: free -h is your friend. If available memory is consistently low (e.g., < 100MB on a 2GB box), you’re swapping. Swapping kills performance. bash free -h If Swap: used is anything more than zero and available is low, you need more RAM.
  • Disk I/O: This is a silent killer. Run iostat -x 1 and look at the %util column for your disk (usually vda or sda). If it's consistently above 70-80%, your disk is your bottleneck. This often happens with heavy logging or database writes. bash iostat -x 1 If disk I/O is the issue, check your database queries, your logging setup, or consider moving static assets to a CDN.

Most of the time, for a solo founder, the bottleneck is your code. You have N+1 queries. You're doing expensive computations on every request. You're loading too much data. Fix the code first. Use cProfile in Python to find hot spots. Add EXPLAIN ANALYZE to your PostgreSQL queries. Optimize your Python for loops.

Scaling Up: When and How

You’ve optimized your code. You’ve confirmed with top, free, and iostat that you’re hitting a resource limit. Now you scale.

  1. Vertical Scaling (Bigger Box): This is your first move. It's the simplest. Go from 1 CPU/2GB to 2 CPU/4GB. It’s usually a few clicks in your cloud provider's UI and a reboot. Total downtime: a minute or two. No code changes. No architectural changes. This buys you a lot of time.
    • Pro Tip: Always snapshot your server before an upgrade. Just in case.
  2. Horizontal Scaling (More Boxes): This is where it gets slightly more complex, but still manageable for a solo founder. You need a load balancer. Nginx can act as a simple one.
    • Scenario: Your single Nginx server is forwarding requests to a single Gunicorn process. Now you spin up a second identical server.

Nginx configuration: ```nginx upstream backend_app { server 192.168.1.10:8000; # Your first app server server 192.168.1.11:8000; # Your second app server }server { listen 80; server_name yourdomain.com;

location / {
    proxy_pass http://backend_app;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}

} `` * This requires shared state (e.g., a shared PostgreSQL database, often on its own server) and stateless application servers. Your app servers should *not* store user sessions in local memory. Use Redis or your database for sessions. * You’ll need a simple deployment script (rsync,ansible-playbook`) to push code to both servers. Keep it simple.

This is still a two-server setup: one Nginx load balancer, two application servers. Very manageable. Your database is probably the next bottleneck, but again, PostgreSQL on a dedicated box can handle a surprising amount of load.

The Database: Your Next Bottleneck (Probably)

Your database is where most people get tripped up. For a solo founder, start with a single PostgreSQL instance. Don't even think about replication or sharding until your single instance is begging for mercy.

When it does:

  1. Optimize Queries: This is 90% of your database capacity planning. EXPLAIN ANALYZE is your best friend. Add indexes. Rewrite inefficient queries.
  2. More RAM: The database loves RAM. It caches data, which means fewer slow disk reads. Upgrade the server.
  3. Faster Disk: NVMe SSDs are your friend. If your provider offers them, use them for your database server.
  4. Read Replicas: If you have a read-heavy workload (most applications do), setting up a read replica is your next step. PostgreSQL streaming replication is robust. You send read queries to the replica, and writes still go to the primary. This offloads a huge amount of work.
    • Pro Tip: Your cloud provider probably has a managed database service that handles read replicas with a few clicks. Use it. This is one area where the operational burden might outweigh the open-source purity for a solo founder. Just don't let them lock you in too deep.

Caching: The Ultimate Scaler

Before you add more servers, add a cache. It's often the fastest way to reduce load.

HTTP Cache (Nginx): For static assets and rarely changing API responses, Nginx can cache directly. ```nginx proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=my_cache:10m inactive=60m max_size=1g;server { # ... location /static/ { proxy_cache my_cache; proxy_cache_valid 200 302 10m; proxy_cache_valid 404 1m; proxy_cache_key "$scheme$request_method$host$request_uri"; add_header X-Proxy-Cache $upstream_cache_status; proxy_pass http://backend_app; # or serve directly } # ... } * **Application Cache (Redis/Memcached):** For frequently accessed data from your database, cache it in Redis or Memcached.python

Example with Redis in Python (using redis-py)

import redis r = redis.StrictRedis(host='localhost', port=6379, db=0)def get_expensive_data(key): data = r.get(key) if data: return json.loads(data) else: # Fetch from DB db_data = fetch_from_database(key) r.setex(key, 3600, json.dumps(db_data)) # Cache for 1 hour return db_data ``` This one-liner will save you countless database queries.

Look, Meta just launched an AI fashion app Meta quietly launches an AI fashion app called Style Sketch, and OpenAI-backed Thrive acquired ADT OpenAI-backed Thrive Holdings acquires ADT. Big players are making big moves. You're not Meta, and you're not OpenAI. Your capacity plan is about survival and shipping, not spending billions.

Automate Everything, Get Your Life Back

Your time is your most valuable resource. Automate the boring stuff.

  • Deployment: git pull on your server is fine for v1. For v2, use a simple shell script or fabric/ansible-playbook. bash # deploy.sh (example) #!/bin/bash cd /path/to/your/app git pull pip install -r requirements.txt gunicorn --bind 0.0.0.0:8000 wsgi:app --daemon --pid /var/run/gunicorn.pid systemctl restart nginx # if you updated static files
  • Monitoring: prometheus + grafana is overkill for a solo founder initially. Start with simple cron jobs to check service status and email you. ```bash # Check if gunicorn is running every 5 minutes */5 *

References

💬 Discuss this article in the community — 0 replies →
Comments live on community.sqs.chat — one thread per article.