Two years ago I spent an entire Saturday debugging a Caddy config that I wrote myself six months earlier and had completely forgotten about.

The app was live. Users were signing up. But I couldn’t remember which server it was on, or how I’d set up the reverse proxy, or why I’d put the SSL renewal cron job on a different machine from the one serving traffic. I was the person who built the thing and I couldn’t tell you how it worked.

That was the moment I got serious about deployment.

The Three Traps

Every solo dev I know eventually runs into the same three options for getting their app online. And every one of them has a catch.

Kubernetes. Spend three weeks learning YAML indentation rules just to serve a Django app that gets 200 visits a day. The ecosystem is genuinely incredible for teams with dedicated platform engineers. For the rest of us? It’s a sledgehammer for a thumbtack.

Manual SSH. Buy a $5 VPS, apt-get install a bunch of stuff, configure a firewall, set up a reverse proxy, cross your fingers, and call it a day. It works until you need to update the app six months later and you can’t remember which config file you edited or why you chmod 777 that one directory.

PaaS lock-in. Vercel, Heroku, Render. They’re great until you outgrow them or your bill triples or you realize migrating away means rewriting half your infrastructure. The convenience is real. The tradeoff is that you’re renting someone else’s decisions.

I’ve spent time in all three. They each have their place. But for the solo dev shipping a real product on a budget, none of them feel right.

This Stack Runs Real Products

I don’t just set this up for clients and I run my own stuff on it too.

ClaroHQ (clarohq.com) is a live SaaS app I built with Django and SQLite. It’s served by the exact pipeline I’m describing here: Docker Compose, Caddy handling HTTPS automatically, and Uncloud sitting on top so I can deploy, restart services, and stream logs without ever SSHing into the server. The database is a single file. The reverse proxy renews its own certificates. I deploy whenever and wherever I want. I’ve been running it this way for over a year, and the most exciting thing I can say about the infrastructure is that nothing exciting has happened.

That’s the kind of boring you want when real users depend on your app.

What I’ll Do for You

I set up a complete deployment pipeline using Docker and an open-source tool called Uncloud. Here’s the short version: you run just deploy from your terminal and your app goes live on your own VPS. No Kubernetes. No platform lock-in. You own the whole thing.

Uncloud wraps Docker Compose and gives you a single command to deploy, restart services, and stream logs. All from your local machine. You never need to SSH into the server for day-to-day operations. And because it’s open source, there’s no company that can rug-pull you by changing their pricing.

I’ve been running this exact stack for my own projects for over a year. It’s boringly reliable. The kind of boring you want from infrastructure.

Here’s what the setup includes:

• Server provisioning with Ansible. I write an idempotent playbook that configures your VPS from scratch. Firewall, SSH hardening, Docker, fail2ban, automated security updates. Run it once or ten times, the result is the same. If you ever need to migrate to a new server, you point the playbook at a new IP and walk away.
• Docker Compose that actually makes sense. Your app, database, reverse proxy, and background workers in a single compose.yml. Caddy handles HTTPS automatically. You will literally never think about SSL certificates.
• One-command deploys. just deploy builds your image, pushes it, and brings your services up. I wire it into a GitHub Actions workflow so a push to main triggers deployment automatically if you want.
• Logs without SSH. uc logs web streams your app logs to your terminal. uc service ls shows what’s running. It’s like having docker compose on your local machine, except it’s talking to a server halfway across the world.

$99. One Time. No Strings.

No monthly fee. No percentage of your revenue. No upsells hidden in the fine print.

You pay once. You get a production-ready pipeline that you own. If you want me to handle ongoing maintenance or manage deployments long-term, we can talk about that separately. But the setup itself is a one-and-done thing.

Is This a Good Fit?

This setup works well if you’ve got a web app that runs in Docker (Django, FastAPI, Rails, Node.js, whatever) and you want to deploy it without becoming a part-time sysadmin. It’s especially good for people who value owning their infrastructure and don’t want to be locked into a platform.

It’s probably not a good fit if you need auto-scaling, multi-region failover, or compliance certifications. If that’s you, I’ll tell you honestly and point you toward something more appropriate.

Let’s Talk

Email me with a quick description of what you’re building. I’ll take a look and let you know if this setup makes sense for your project. If it does, we’ll hop on a short call and I’ll get you deployed within a few days.

I’d rather tell you it’s not a fit than sell you something you don’t need.