SRE on Coffee or Blog

Why Doesn't Anyone Own That?

Mon, 23 Mar 2026 00:00:00 +0000

It’s 5 PM on a Thursday. Something broke mid-morning and your team has been grinding on it for hours. Good engineers, working hard, coming up empty because the system is poorly documented and the people who built it have either moved on or moved teams. You’ve burned most of the day and you’re no closer to resolution.

So you escalate. You ping the leads. You ask in the channel where someone, surely, knows this service well enough to point you in the right direction.

Silence.

Not because nobody cares. Because nobody actually owns it. There’s a name in the CMDB, but that person will tell you they haven’t touched it since a reorg reshuffled their priorities. There’s a runbook, but it describes a version of the system that no longer exists. There’s a Slack channel with forty members and no clear authority.

This is where the real cost of diffuse ownership lives. Not in the architecture review, not in the postmortem writeup. Right here, in a live incident, with a team that has already spent most of a day spinning their wheels and a business that is losing patience.

The easy diagnosis is that engineers don’t want ownership. Nobody wants the accountability when something critical falls over. That read is intuitive, and it’s mostly wrong.

Most engineers I’ve worked with want to own something. They want the stakes, the identity, the sense that they know a system cold and it shows. Ownership is a fundamental motivator in this work. It’s one of the few things that makes the job feel like more than ticket throughput.

The problem isn’t appetite. It’s that we’ve built organizations that punish people for taking it.

We say we want owners. Then we punish them.

Most performance systems weren’t designed to reward operational excellence. They were designed to measure visible output — features shipped, projects delivered, things a manager can point to in a calibration meeting and defend. Keeping a critical service healthy produces none of that. No launch. No demo. No ribbon cutting.

Here’s what it does produce: a rating of “meets expectations.” Which, in most four-point HR scales, means no raise. Sounds fair until you consider that the engineer just spent a quarter instrumented to the gills on a service that didn’t go down, pushed for refactors the team had been deferring for two years, and responded to every incident that came their way. They did their job flawlessly. The organization scored it as ordinary because ordinary is the only category it fits in.

That engineer is not doing that again next year. Neither is anyone who watched it happen.

The performance review is just the most visible mechanism. The same signal gets sent in sprint planning when operational work gets bumped for roadmap items, in reorgs when the “boring” platform work gets deprioritized, in how leaders talk about the team that keeps things running versus the team shipping the new thing. It accumulates. People are paying attention even when you think they aren’t.

Rational engineers respond rationally. Ownership becomes a liability, ambiguity becomes protection, and the next time someone asks who owns the broken thing, there genuinely isn’t an answer.

Accountability without authority is just blame.

There’s a second trap that even well-intentioned leaders fall into, and it’s more insidious than the performance review problem because it often comes wrapped in the language of empowerment.

We assign ownership without giving people the actual power to act.

Think about what that looks like in practice. An engineer is named owner of a critical platform service. They identify that the deployment process is bypassing validation steps and creating instability. They flag it. They write it up. They ask for a two-week pause on releases to address it. The response from leadership: “We can’t stop the roadmap, let’s find another way.” There is no other way. The service degrades, falls over, and in the postmortem the question on the table is why the service owner didn’t catch this sooner. It plays out constantly, in slightly different costumes, and the person in the owner role learns the same lesson every time.

Ownership without the authority to say no to a risky deployment, to pull capacity from feature work when a system is genuinely at risk, to set a standard and enforce it — that isn’t ownership. It’s a title with no teeth. The person holding it gets the pager, gets the postmortem questions, gets the performance conversation, and had none of the leverage required to prevent any of it. Smart engineers recognize that setup fast. Word travels.

The organizations that do this aren’t malicious. Most of them genuinely believe they’ve created clear ownership. They put a name in a doc and called it done. What they actually created is a designated scapegoat with a service catalog entry.

The cost is higher than you think.

Diffuse ownership doesn’t just create operational risk, though it absolutely does that. It degrades the institutional knowledge your organization depends on.

When nobody owns a system, nobody deeply understands it. Documentation becomes aspirational fiction. Runbooks describe what someone intended the system to do, not what it actually does. Incidents take longer, cost more, and teach less, because there’s no through-line of accountability that connects cause to effect to learning.

And the talent impact is brutal. The engineers who want to own things, the ones you most want to retain, will eventually get tired of operating in that vacuum. They’ll go somewhere that lets them. The engineers who remain will have self-selected for comfort with ambiguity and low accountability. That is a culture you cannot easily reverse.

What actually changes this.

This isn’t a process problem. You can’t RACI-chart your way out of a culture that punishes ownership. You have to change what you reward.

Start with how you evaluate performance. If your engineering managers cannot point to explicit, visible credit given to engineers for operational ownership — in promotion cases, in calibration sessions, in public recognition — then you are implicitly telling your team that it doesn’t count. Fix that first.

Next, make ownership legible. A service with a named owner, a clear charter, and explicit authority boundaries is a service people will actually step up to own. Ambiguity is where accountability goes to die. Define the thing. Name the owner. Give them real power over their domain.

Toyota figured this out on the factory floor decades ago. Their Andon system gives any line worker the authority to stop production the moment they identify a problem — not escalate it, not flag it for later, stop it. The entire premise is that the person closest to the issue has both the standing and the backing to act. It works because leadership built a culture where pulling that cord is the right call, not a career risk. We’re supposedly more sophisticated in software, yet we routinely put engineers in positions where they can see the problem clearly, have no authority to stop anything, and get blamed when it blows up anyway.

Back your owners when it’s hard. When someone pulls the cord on a deployment, or pushes back on a timeline because the system genuinely can’t absorb it, support that call publicly. If you quietly override it three times, you’ve taught everyone watching that ownership is theater.

The question worth asking.

The next time you find yourself in that room, the incident is running, the silence is thick, and nobody’s hand goes up, resist the urge to blame your people.

Ask instead what you, and the organization above you, built that made this feel like the right call.

Because I promise you: somewhere, at some point, someone tried to own that thing. And something happened that taught them not to.

Your job is to find out what that was, and fix it.

Good ownership isn’t found. It’s cultivated, or it’s extinguished. Pick one.

The Lie That Taught Me About Blameless Culture

Fri, 09 Jan 2026 00:00:00 +0000

I was standing outside a conference room watching my team lie to another team about a database outage. It was day four.

Through the glass door, I could see the engineer on the call, explaining with impressive confidence that our cloud provider was having issues. Any minute now, they said, the vendor would resolve it and services would come back up.

I pulled up the provider’s status page. Green across the board. Checked their Twitter. Nothing. I caught the eye of the engineer leading the response and motioned them outside.

“What actually happened?”

The way they looked at the floor told me everything. Then: “Accidental deletion. We’re working on recovery.”

Here’s the thing about inheriting a team: You don’t just inherit their code and their systems. You inherit their patterns. Their fears. The lessons they learned from whoever led them before you.

My team had learned that mistakes meant consequences. That admitting fault meant exposure. That the safest play was to redirect blame to something faceless—a cloud provider, a vendor, a system “acting weird.” They’d learned this so well that lying to the team we supported felt safer than telling their new boss the truth.

I had about thirty seconds to decide what kind of leader I was going to be.

The Conversation

We found an empty office.

“I’m not mad about the database,” I said. “I’m concerned you felt you couldn’t tell me.”

They stared at their hands.

“I need you to understand something. I’m four days into this role. I don’t know your systems. I don’t know the history here. But I know this: I can’t help you fix problems I don’t know about. And the other team can’t tell us how severe this actually is if we’re feeding them fiction.”

“Previous leadership didn’t react well to mistakes.”

There it was. The inherited culture, delivered in one sentence.

“Okay. Here’s the new standard: You tell me the truth, always. I’ll handle the hard conversations. You focus on the fix. Deal?”

They looked up. “Deal.”

Falling on the Sword

I walked back into that conference room.

“I need to correct something,” I said. “This isn’t a cloud outage. One of our engineers accidentally deleted the pre-production database. We’re working on recovery now, but I need your help: How critical is this to your operations? What’s the actual impact?”

The silence lasted maybe three seconds. Felt like an hour.

Then: “Thank you for being straight with us. Here’s what we need…”

They walked us through their priorities. Which services mattered most. What data they could recreate versus what needed restoration. The conversation became a collaboration instead of a performance.

We got the database back. It took six hours and some creative recovery work, but we got it back.

The Post-Mortem

The next day, I gathered the team in the conference room for our first post-mortem. I’d never run one with them before, so I started by explaining how we were going to do them from now on.

“When we name people in post-mortems,” I said, “it’s only for successes. Who responded quickly. Who had the knowledge to guide recovery. Who communicated clearly under pressure.”

I looked at the engineer who’d led the recovery effort. “You did excellent work getting us back online.”

“For failures, the buck stops with me. I’m the lead. Anything that goes wrong happened on my watch. My job is to figure out what systemic failures allowed this to happen and fix them.”

I watched the team process this. Some looked skeptical. Some looked relieved. All of them looked like they were waiting for the other shoe to drop.

“Here’s what we’re changing. Permissions on production-like environments. Backup verification procedures. Documentation on recovery processes. And most importantly: the expectation that you can always tell me the truth, especially when things break.”

The Timing

Looking back, week one was actually the perfect time for this to happen.

I had no history with this team. No pattern of reactions for them to predict. No baggage about “how we’ve always done things.” When I said “this is the new standard,” there was no previous version of me to contradict it.

Being new meant I had nothing to lose and everything to prove. I couldn’t lean on established trust or authority. I had to show them, in real time, what kind of leader I was going to be.

Culture isn’t built during the smooth times. It’s built in how you respond when things break. And things always break.

What Stuck

That engineer never lied to me again. Neither did anyone else on the team. Not because I’d scared them straight, but because I’d shown them the alternative: honesty gets you help, not punishment.

The other team? They became one of our strongest advocates. Years later, they still reference that incident as the moment they knew they could trust us.

The post-mortem approach stuck too. Name people for successes, take responsibility for failures. It sounds simple, but it changes everything about how teams respond to pressure.

I couldn’t change what my team had learned before I arrived. I couldn’t undo whatever had taught them that self-preservation trumped transparency. But I could show them a different future, starting with one deleted database and one honest conversation.

The bad news: People will test your principles during crisis. The good news: Crisis is when principles matter most.

The job is to be ready anyway.

Everything I learned about Ops, I learned playing goal

Thu, 06 Nov 2025 00:00:00 +0000

Well, maybe not everything.

Look, being a goalie is objectively ridiculous. You strap on forty pounds of equipment designed to protect you from frozen rubber traveling at speeds that would make physicists frown. Then you stand in front of a net and dare people to shoot at you. It’s a strange job.

But here’s the thing: being a goalie is basically the same job as running ops, or security, or honestly, any part of software development where you’re the one who has to keep the thing from breaking.

Both jobs share the same core truth that nobody tells you in the job description: when everything’s working, no one notices you’re there. But the second something gets past you? Everyone knows exactly where you were and what you should have done differently.

You spend most of your time reading patterns, anticipating problems before they fully materialize, and communicating with people who may or may not be listening. You’re simultaneously trying to follow the systems that keep you consistent while also staying loose enough to react when something weird happens. Because something weird always happens.

And whether it’s a breakaway in overtime or a production incident at 2 AM, you learn pretty quickly that freezing up isn’t an option. You make the save or you don’t. You stop the breach or you don’t. Then you’ve got about eight seconds to shake it off and get ready for the next shot, because there’s always a next shot.

The bad news? You can’t stop everything. The good news? Neither can anyone else. The job is to be ready anyway.

New Team, New Processes

Mon, 31 Mar 2025 00:00:00 +0000

Starting fresh with a new team—whether it’s stepping into the net as a goalie or joining a company as a Site Reliability Engineer—comes with a rush of excitement, uncertainty, and the need to quickly adapt. In both worlds, you’re expected to understand the system, earn trust fast, and make the right decisions under pressure. This piece explores the parallels between guarding the crease in ice hockey and taking on infrastructure responsibilities in a new engineering org: the importance of communication, learning team dynamics, managing risk, and building confidence through early wins.

When you join a new hockey team as a goalie, you don’t just protect the net—you learn how the defensemen play, how aggressive the forwards are, and when the team tends to collapse or stretch the ice. Every team has its own rhythm and unspoken rules. The same is true when joining a new company as an SRE. The architecture is only part of the story; the real learning curve is understanding how incidents are handled, who actually makes the calls in a crunch, and which “informal” channels carry the most context. Just like a goalie can’t force their style on a team that plays differently, a new SRE needs to observe, adapt, and gradually find ways to complement and strengthen the existing flow. It’s less about proving you’re technically sound (that’s assumed) and more about showing that you can read the play and make the team better as a result.

In both hockey and SRE work, the moment things go sideways is when communication really counts. As a goalie, you see the whole ice—you’re the only one facing the play—and you need to call out shifts, loose players, or breakdowns in real time. If you hesitate, the puck’s in the net. As an SRE, it’s similar during an incident: you often have a high-level view of what’s happening across systems, and the ability to stay calm and clearly relay what you’re seeing can make the difference between a contained issue and a full-blown outage. But communication isn’t just about shouting the loudest—it’s about knowing when to speak, who needs to hear what, and doing it in a way that builds confidence rather than panic. Like a goalie steadying the team during a penalty kill, an SRE who brings calm clarity in high-stakes moments becomes an anchor for everyone else to rally around.

So, how do you build trust in a new team?

Trust isn’t earned by pretending to be perfect—it’s built by showing up consistently, being accountable, and owning your impact, good or bad. As a goalie, you’re going to let in goals. Some are unstoppable, some are a result of defensive breakdowns, and some are just flat-out on you. What matters is how you handle it. Do you sulk? Blame? Or do you skate over, tap a teammate’s shin pads, and reset for the next faceoff? The same dynamic plays out in SRE. Early on, you’ll miss signals, ship a bad change, or overlook something you should have caught. Heck, there are days where you’ll break production. But by being transparent, acknowledging the miss, and showing what you’re doing to improve, you demonstrate humility and build credibility. Teams trust people who are honest about their fallibility and show a pattern of learning. Whether it’s a soft goal from the point or a mistuned alert that paged the team at 3 a.m., owning it builds more goodwill than perfection ever could. That openness also invites others to bring their guard down, leading to better collaboration and stronger long-term bonds.

As both a goalie and a leader, you quickly learn that most mistakes aren’t rooted in malice or incompetence—they’re byproducts of unclear systems, missing context, or just the fast pace of the game. When someone misses an assignment on the ice or forgets to update a runbook, it’s rarely because they don’t care—it’s usually because the process failed them. As an SRE leader, it’s your job to zoom out after the fact and ask not just who made the mistake, but why it made sense in that moment—and how the system can be improved so the next person has a better shot. Maybe the alert was noisy, the handoff lacked key context, or a dependency wasn’t clearly documented. Whatever it is, you shift the focus from blame to learning. Like a goalie giving quiet guidance during a timeout, your job is to reset the team without undercutting their confidence. Owning your own mistakes gives you the credibility to address others with empathy—and turning those moments into durable process improvements is how teams get stronger over time.

Whether you’re stepping onto the ice or into a new engineering org, the fundamentals are the same: learn the team, communicate clearly under pressure, take ownership, and lead with empathy. Both roles are high-trust, high-impact, and deeply human. You’re not just reacting—you’re anticipating, supporting, and constantly adjusting to help the people around you succeed. The best teams don’t expect perfection—they expect presence, accountability, and a shared commitment to get better together. In the end, it’s not about never letting a goal in or preventing every outage. It’s about being the kind of teammate who learns fast, shows up when it matters, and helps turn every setback into forward motion.