The platform team you don't have to hire

I run infrastructure that, a few years ago, would have needed a team of people to operate. There is, for now, no team — it’s me. That isn’t a boast. It’s the reason the prices are what they are, and it’s also the first thing you should be suspicious of. This piece is about both halves of that sentence, because you shouldn’t take the first without the second.

The heavy lifting keeps disappearing

Twenty years ago, running software as a business meant renting space in a building, buying servers, and hiring the people who kept them alive. Then the hyperscalers took that whole layer away. You stopped needing a room, a generator, and someone who knew the difference between a good UPS and a fire — you needed a credit card. Most of the companies you use today exist because that shift lowered the bar to start one.

A smaller version of the same shift is happening one layer up, and it’s the reason a company like this can exist at all.

Running the platform — the Kubernetes control planes, the private networks, the monitoring, the plumbing between them — has, until recently, taken a team. Not because any one piece is exotic, but because there’s a lot of it and it all has to be operated: upgraded, secured, backed up, watched at night. That’s the undifferentiated heavy lifting of the platform layer, and for years the only ways to have it were to hire for it or to rent it from someone whose price reflected the team they hired.

Three things changed at roughly the same time:

• The open-source building blocks matured to where you assemble them instead of writing them. I run etcd; I don’t build it. Kubernetes, WireGuard, Postgres, and the operators around them are load-bearing and boring, which is exactly what you want from the foundation.
• Commodity compute got genuinely cheap — a European server company will rent you real cores for a price that used to buy you a virtual fraction of one.
• AI-assisted development compressed the work of writing and operating the glue that ties those blocks together into something a very small number of people can carry.

None of those is the whole story alone. Together, they delete most of the platform team.

What that actually buys

This isn’t a productivity anecdote; it’s a cost structure. A twelve-person, venture-funded company building a bespoke platform has to price to cover twelve people and the investors who paid for them. An operation that runs the same class of service by assembling mature parts has genuinely lower costs — not lower because someone is being generous, lower because the base underneath is smaller. That distinction matters, because it’s the part that’s hard to copy: a competitor can match a price for a while by spending someone else’s money, but they can’t match a cost base.

What I want to do with that room is narrow and specific. Push the cost down as far as it goes, keep a margin modest enough to be defensible and large enough to keep the lights on, and hand the rest to the person paying the bill. The people I’m building for — a solo project, a five-person team, a twenty-person company that has started to see real traffic — are the ones who feel every euro of infrastructure overhead, because they’re spending it, not raising it.

The part you should be suspicious of

Here is the thing nobody in my position says out loud, so I will: this is a lean operation, and for infrastructure that should make you ask a hard question before you trust it. A tiny team, AI in the loop, running my production control plane can be read two ways, and the skeptical reading is the correct place to start. A hand-wave here would undo everything above it, so let me answer it properly. There are two different worries inside that question, and they don’t have the same answer.

“What if you go away?” — the one people mean by bus factor. The answer is built into how the thing is made: standard components and standard interfaces, the whole way down. Your cluster is a conformant Kubernetes cluster. Your network is WireGuard. If this company disappears tomorrow, or you decide you’ve had enough of me, you take the nodes you already own, stand up your own control plane — genuinely not hard — point them at it, and carry on. The exit isn’t a risk I’m hoping you won’t notice; it’s a property I build toward. Worst case is an afternoon of migration and a slightly awkward goodbye, not a hostage negotiation.

“Are you up tonight?” — a different worry, and “you can leave” is no answer to it. Being able to migrate in six months is cold comfort when something breaks at 3 a.m. That one has its own answer, in two parts. First, the blast radius is bounded by design: when a managed control plane has a bad moment, your workloads keep running — the nodes don’t forget what they’re doing; what you lose for a while is the ability to change them, not the things themselves. The mesh behaves the same way: if the coordination plane is down, the tunnels that are already up keep carrying traffic. An incident on my side is not the same event as your production going dark. Second, I don’t get to tell you it’s reliable — I have to show you, which is why our own uptime and health are measured on the same tools we sell and published where you can see them. Where I can’t promise something yet, the move I respect is to say so plainly rather than dress up a guarantee I can’t stand behind.

The deal

Put those together and you get the arrangement, which I prefer to a lock-in contract anyway: I have to earn it every month. The price has to stay low enough that buying from me beats building it yourself, and the reliability has to be good enough — and visible enough — that you don’t want to. The day either stops being true, the door is open, and it always was.

The same small size that makes you ask the hard question is what lets me hold the price where it is. The open exit is what makes that small size safe to bet on. Those aren’t in tension; they’re one design decision seen from two sides.

So that’s the frame, said before I’ve earned it: the model is the experiment, and I’ll admit that freely. The infrastructure underneath it is not an experiment — it’s assembled from boring, proven parts and run like it matters, not least because it’s running my own work too. If you do the arithmetic and standing this up yourself comes out cheaper and better for what you’re doing, then do that. Genuinely. I only win if it doesn’t.

In the next couple of pieces, I’ll show that arithmetic instead of asserting it — what a control plane actually costs to run, what we charge for it, and the gap in between, with the numbers on the page.