Why I Stopped Renting My Stack and Started Owning It

At some point last year, I sat down and actually added up what I was paying for cloud services I half-used, and the number that emerged was not ruinous, exactly, but embarrassing in the specific, quiet way that receipts can be embarrassing: not because of the total, but because of what the total was for. A note-taking app here, a file sync tool there, a form builder I had opened exactly twice and apparently decided deserved a recurring memorial in my bank statement.

The composition was the problem, not the quantum.

Each of those subscriptions was charging me to run software on hardware I had no visibility into, in exchange for a product experience I could not inspect, back up in any meaningful way, or extract myself from without some degree of friction and a CSV export that captured about sixty percent of what I actually cared about. I was, in the precise technical sense, renting. And at some point last year, with the specific kind of clarity that arrives at 11pm when you are procrastinating on something else entirely, I decided to stop.

So I started migrating. One service at a time, onto a single VPS sitting in a data centre in Mumbai (which is, I assure you, exactly as glamorous as it sounds). Nextcloud replaced the file sync subscription. Traefik handles routing and TLS across the whole stack, which means I haven't thought about certificate renewal in months and I am choosing to interpret this as a sign of good engineering rather than impending catastrophe. Docker Compose keeps everything reproducible and readable, which is the infrastructure equivalent of a tidy desk: deeply satisfying as a principle, occasionally aspirational in practice. The whole thing runs on two cores and eight gigabytes of RAM, and the monthly cost is less than a single one of the subscriptions it replaced. Sometimes considerably less.

Here is the thing I want to be clear about: this is not an ideological position. I am not making a statement about privacy, or surveillance capitalism, or the moral hazard of relying on hyperscalers. Those arguments exist, some of them are even compelling, and I genuinely distrust the genre of tech-writing whose primary function is to let the author feel principled while describing their homelab setup. That is not this.

The practical case is simpler. When I run my own services, I know exactly what is running. I can read the compose file. I can inspect the container logs. I can write a backup script that I actually understand, verify it restores correctly, and trust that this is true because I tested it under conditions that constitute a real test (which is to say, under mild panic, at an hour no one chooses voluntarily). When a tool I rely on gets acquired and the new owners pivot to enterprise pricing, I do not care. I am the operator, not the customer, and the distinction is not trivial.

Here is what I think most self-hosting writing does not say plainly enough, though: the case against is real, and it is not just about technical competence. There is a genuine maintenance cost to running your own services, one that scales not only with the number of containers but with your tolerance for thinking about infrastructure as a category of weekend activity. Upgrades are usually smooth until they introduce a breaking change on a Friday evening. Certificate renewals are usually automatic until they are not. The tail risk is low, but it exists, and if your honest preference is to never again in your life have to think about this class of problem, then you should pay for the SaaS. That is not laziness; it is a correct allocation of limited attention, and I will not condescend to it.

For me, the cost is acceptable. More than acceptable, actually, which is the part I did not entirely anticipate going in. There is something clarifying about understanding the full stack of a thing you use every day, a familiarity that builds in small, incremental moments: watching a health check flip green after a config change, reading a Traefik log as a certificate negotiates, knowing that a file you just synced lives on hardware you have a contract with rather than an abstraction you have a subscription to. The accumulated intimacy of a system you actually understand is not nothing.

Some migrations are still pending. A few services remain unself-hosted because no good alternative exists at the quality level I need; a few others remain because I have not gotten around to them, and I try to be precise with myself about which reason applies to which case.

But the number in the bank statement is smaller now, and more to the point, I understand every line of it.

That turns out to be worth more than I expected: not just what you run, but what you know.