Developers Shouldn't Own Their Infrastructure


My first real team was app support. We owned the infrastructure every application ran on, and we were the ones who got called when it broke. A lot of my days were spent helping developers get their app deployed through Puppet and setting up their Jenkins pipelines so they didn’t need me every time they pushed a change.

I didn’t have a name for it back then, but that was the job. Make it so developers could ship without having to think about what was underneath.

Then “you build it, you run it” took over. Werner Vogels said it back in 2006 about how Amazon worked, and the industry ran with it. And honestly, it fixed a real problem. Developers threw code over the wall, ops caught it, and the people who wrote it were never the ones up at 2am. I was on the catching side of that wall. I get why it changed.

But I think we took it too far. Somewhere along the way, running your app turned into owning everything under it too. Your own databases, your own Lambda functions, your own Terraform, your own cluster upgrades. And in my opinion, most developers shouldn’t be doing that.

I know how this sounds coming from a platform architect. Bear with me.

When a product team owns its infrastructure, it usually doesn’t get owned. It gets set up once. Someone copies what the last project did, gets it working, and moves on, because the team is measured on features and the infra is just the thing in the way. I don’t blame them. I’d do the same.

The problem shows up a year or two later. Versions fall behind. Nobody wants to touch the Terraform because the person who wrote it is on a different team now. If you’re on EKS and you fall far enough behind, AWS starts charging you extra for extended support. You’re literally paying because nobody’s job was to keep it current.

And that’s one team. A big company has dozens of them, all doing their own version of the same thing, all drifting in different directions.

There’s just too much to know now. Building a good service is already hard. Databases, Lambda functions, IAM, networking, observability, those are each their own thing that people spend years getting good at. Expecting a product team to be good at all of it on top of their actual work isn’t fair to them.

Now, I tell my students to take the on-call job. I built a whole course on containers. So I’m not saying developers shouldn’t understand infrastructure. I think they should. I want them to be able to read a pod spec and figure out why their container keeps getting OOMKilled. Understanding it is one thing. Being the one responsible for keeping it patched and upgraded is something else.

What I’d rather see is what my old team was doing, just done better. A platform team whose whole job is making the infrastructure easy to use. Developers still own their app. They get paged when it breaks, they own their deploys and their alerts. They just aren’t also maintaining the cluster it runs on.

Don’t get me wrong, this can go bad too. If the platform team turns into a ticket queue where you wait two weeks for anything, developers are going to go around it, and I wouldn’t blame them for that either. A platform team only earns its place if using it is easier than doing it yourself.

So how do you actually get it right? I’ve thought about this a lot, and I keep coming back to a few things.

First, the common stuff has to be self-service. If a team needs a database, they shouldn’t have to file a ticket and wait. They should be able to grab a module, fill in a few values, and have a database with backups, encryption, and monitoring already set up. Nobody had to remember to turn those on, because they were never optional. Most teams need the same handful of things over and over. Those should take minutes, not weeks.

Second, the platform team owns the upgrades. This is the whole point. When AWS deprecates a Lambda runtime, fifty teams shouldn’t each be finding out on their own when something stops deploying. The platform team should already know it’s coming, update the shared pieces, and make the upgrade as close to a version bump as they can. If every team still has to do the work themselves, you haven’t really taken anything off their plate.

Third, let people leave the road. Some teams really do have a weird use case, and the platform won’t fit every one of them. That’s fine. Let them go build their own thing. But if you go off the road, you own what you build. That keeps it fair. Most teams will stay on the road because it’s easier, and the ones who leave usually have a good reason.

Fourth, and this is the one I care about most, the platform team has to actually talk to developers. Sit with them. Watch them try to use what you built. When I was setting up Jenkins pipelines on that app support team, I learned more watching a developer get stuck than I ever did from a ticket. If the platform team only hears from developers when something is broken, they’re building for themselves, not for the people using it.

And last, I think the real test is whether people choose it. If you have to force teams onto the platform with a mandate, it’s probably not good enough yet. When it’s actually easier than doing it yourself, people show up on their own. Then adoption tells you whether you’re getting it right.

And if you’re a startup with ten engineers, none of this applies. Everybody owns everything, and that’s just how it is at that size.

But once you’re big enough that a bunch of teams are solving the same infrastructure problem on their own, I think that’s a sign you need someone whose job it is.

That’s my take. I’m sure some of you are going to tell me I’m wrong. If your team owns its own infrastructure and it actually works, I want to hear what makes it work.