Own Your Infrastructure

In an essay I wrote years ago about why we taught Ruby first, I bragged that Heroku was a Rubyist invention. I called it "the mother of no-hassle, virtualized, web application hosting."

I meant it. git push heroku main and your app was live. No reverse proxy, no SSH, no certificates. It was the most Ruby thing in the world: a platform that valued the programmer over the machine.

Heroku, then Render, then Vercel for the frontend stuff. Every time the reasoning was the same: my time is worth more than the markup, and I don't want to be the guy who gets paged because Postgres ran out of disk.

That reasoning was right. It isn't anymore.

What we were actually paying for

Managed platforms never sold compute. They sold not having to know things.

Linux administration. Docker networking. nginx config. TLS. Postgres tuning, backups, restores. Firewall rules. Why a box is swapping at 3am. That knowledge was expensive, rare, and honestly a little scary. A good DevOps person cost more than most of us could justify, and learning it yourself meant months of man pages and broken servers.

So we paid a tax and called it productivity.

Claude knows all of that. It writes a Caddyfile, reads journalctl, sets up ufw, tunes shared_buffers for the RAM you actually have, and writes a pg_dump cron that ships to R2. It knows Traefik labels. It knows why your container keeps restarting. The knowledge gap that justified the markup is gone.

The bill

Roughly what a small pile of side projects cost me on managed platforms. Numbers from memory, not a pricing page.

MANAGED (monthly, roughly)
  Vercel Pro, a couple of seats                 ~$40
  Bandwidth + function overages                 ~$20-60
  Managed Postgres (2 small instances)          ~$100
  Managed Redis                                 ~$30
  Log drain / monitoring add-on                 ~$25
  A couple of Render/Heroku web + worker dynos  ~$80
                                                ------
                                                ~$300-350/mo

SELF-HOSTED (monthly, roughly)
  One dedicated Hetzner box
  (lots of cores, 64GB RAM, NVMe)               ~$50-70
  Coolify                                       free (self-hosted)
  Off-site backups to R2                        a few bucks
                                                ------
                                                ~$60-80/mo

That one box runs eight apps right now. Rails apps, a couple of Next.js things, Postgres for each, Redis, a GoodJob worker or two. It has headroom I'm not close to using.

And the managed column scales the wrong way. Every new project adds a database, a dyno, a seat. On the box, a new project is another container on hardware I already paid for.

The bill is the least interesting part

Self-hosting was always cheaper. Nobody was confused about that. We paid anyway, for everything else. So here's everything else.

The row that changed my mind is debugging. What scared me about self-hosting was never the bill. It was the night something breaks.

Last month one of my apps started throwing 502s. On Heroku I would have stared at the metrics tab and restarted dynos until it went away. Instead I opened Claude Code and typed:

The app at jobs.example.com is returning 502s. SSH into the Hetzner box
(host alias: hetzner-1), find the container, check docker logs and
resource usage, and tell me what's going on before you change anything.

It ran docker ps and found the container restarting in a loop. It pulled docker logs --tail 200 and saw Puma workers dying. docker stats and dmesg confirmed the kernel was OOM killing them. Then it traced it to a GoodJob batch loading an entire table into memory, proposed a find_each fix, and suggested a memory limit on the worker container so one bad job couldn't take down the web process.

Ten minutes. I read the diagnosis, approved the fix, it deployed.

A managed platform hides the machine from you. That was the whole point when you were the one who had to understand it. Now it hides the machine from the agent too, and the agent is the one doing the debugging. A black box with a metrics tab is worse support than a box an agent can walk into at 11pm.

Coolify is the PaaS, you just own it

Coolify is what made this click for me. It's a self-hosted Heroku. Point it at a server, connect GitHub, and you get git push deploys, one-click Postgres and Redis, automatic SSL, preview deployments for PRs, environment variables, and a dashboard that looks like the thing you were paying for.

The difference is the dashboard runs on your box, and the box runs whatever you want. That matters more now that I'm splitting things into smaller services in one repo. Eight containers on one box costs the same as one.

If everything you run is Rails, Kamal might be all you need. It ships with Rails now, it's just Docker and SSH, and a few lines of config/deploy.yml get you zero-downtime deploys to any server you can reach. I use Coolify because I run a lot of apps in a lot of languages and I like one place to see them all.

When managed is still the right call

That last row of the table is real. If you need SOC 2 or HIPAA, or a contract that says someone else is responsible for the database's physical security, buy it. If you need multi-region failover and a database that survives a data center going dark, the big providers spent billions on that. Don't rebuild it on a weekend.

And one box is one box. If it dies and nobody notices for six hours, that's on you. You need backups you've actually restored, monitoring that pings your phone, and a plan. An agent can set all of that up in an afternoon, but someone still has to answer the phone.

For side projects, internal tools, and early products with a few hundred users, none of that applies. That's exactly where managed pricing hurts most and buys the least.

The old advice was to use managed until you outgrow it. I think it's flipped. Run your own until you have a real reason not to. We avoided ops because it was hard, and it isn't hard for the thing doing most of the work now. That's the whole series in one sentence, really: Rethink Everything is a list of preferences that made sense when humans carried the knowledge.

Next up, the abstraction I preached hardest: why I'm choosing duplication over DRY so agents stop stepping on each other.