lab.victoriza.com / accountability & ownership / facilitator guide

Accountability & Ownership

A facilitator's study guide to the six patterns of broken ownership — what to know, what to say, and what to ask the room. Light on theory, heavy on monkeys.

Open the slides →

Ownership= Knowledge+ Mandate+ Responsibility

Before you start

Session at a glance

Plan about 20 minutes for the six patterns, so each speech here runs 60 to 90 seconds out loud.

Patterns 1 to 3 are short and punchy (about 5 minutes together). Patterns 4 to 6 each get a short card plus a worked example of about 3 minutes. Every pattern below follows the same shape: the card, study notes, your speech, examples, extra input, and what to ask the room.

The one formula to repeat all session: ownership needs knowledge, mandate and responsibility. Take one away and it breaks. Take two away and it breaks in a more entertaining way.

The three elements

ElementWhat it meansQuestion to ask
KnowledgeHow the system works and why it failsDo we understand the domain, the system and its risks?
MandateAuthority and levers: access, approvals, time, budgetCan we decide, touch the system, and spend the time or money?
ResponsibilityOn the hook for outcomes: SLAs, incidents, follow-upAre we the ones answering for success, failure and recovery?

If someone asks for a sharper definition: decision rights are what you can change without asking; resources are people, budget and time; accountability means you're judged on results, and an external cause is not an excuse. External causes still need to be spotted early, then handled or escalated.

Knowledge Mandate Responsibility ComaK only Monkeywith a gunM only TeenagerK + M OwnershipK + M + R Foot soldierK + R GamblerM + R BabysitterR only

Each pattern sits where its elements overlap. The fix is always to move toward the centre by adding what's missing.

The six patterns in one table

PatternHasMissingSay it in one line
🔫 Monkey with a gunMandateKnowledge, ResponsibilityCan act, doesn't understand, won't pay
💤 ComaKnowledgeMandate, ResponsibilityHas the brain, not the keyboard
👶 BabysitterResponsibilityKnowledge, MandateGets called when it cries, has no house keys
🧒 TeenagerMandate, KnowledgeResponsibilityWants the licence, not the parking ticket
🪖 Foot soldierKnowledge, ResponsibilityMandateOn the hook, but the hook is on someone else's wall
🎲 GamblerMandate, ResponsibilityKnowledgePays the bill for bets made on gut feeling

The framework comes from Alex Ewerlöf's article Broken ownership. Credit him when you introduce it.

Pattern 1 · Mandate only

🔫 Monkey with a gun

KMR
~90 seconds

The Monkey can act, but doesn't understand the system and won't be around for the consequences. Open with it: it's the most dangerous pattern and the one the room recognises fastest.

Symptoms

Top-down decisions; little exposure to operations.

Impact

Micromanagement, rework, demoralised experts, incidents, loss of trust.

Fix

Add responsibility (on-call, incident ownership) and grow knowledge (reviews, observability, time to learn). Whoever decides feels the consequences.

Study notes

  • It grows in top-down cultures with low trust, big egos and a fixed mindset. The decider takes control but doesn't actually run anything.
  • The classic case is the ex-developer manager who "knows enough to be dangerous" and pushes opinions when the team doesn't push back.
  • It isn't always a manager. A junior with admin rights to production, or a team pushing a release during the busiest sales day of the year, is the same pattern.
  • Don't confuse it with the Gambler. Both lack knowledge, but the Gambler pays for the outcome; the Monkey doesn't. That missing bill is what makes the Monkey worse.
  • The upside, if anyone asks: quick action and no bureaucracy. That's why it keeps coming back.

Your speech

Let's start with the most dangerous combination: someone who has the authority to act, but neither the knowledge nor the responsibility. Ewerlöf calls it the "Monkey with a gun." No offence to monkeys — they at least don't schedule Friday rollouts.

This person can deploy, change configuration or make the call. But they don't really understand the system, and they won't be the one on the incident bridge at 11pm. It's like handing someone the car keys, pointing at the accelerator and forgetting to mention where the brakes are.

You'll recognise it by top-down decisions, people far from operations, micromanagement, rework, and experts who have quietly stopped arguing.

The fix is not to take the gun away. It's to add what's missing: time to understand the system, reviews and observability — and if you make the decision, you join the incident call when it goes wrong. Funny how fast Friday rollouts disappear once the decider is on call.

Examples to pull out

  • An exec mandates a Friday rollout without reviews and doesn't join the incident bridge when it breaks.
  • An ops leader forces a database config change "for performance" with no SLO ownership and no rollback plan.
  • A product team promotes a change to production on peak-traffic day and takes the site down.
  • A small, well-meant change to a field in a central system cascades through a sync and removes access to a dozen tools for hundreds of people. Nobody had mapped the dependency chain.

Extra input

  • "You build it, you run it." Werner Vogels (Amazon CTO) coined it in 2006. It's the antidote to the Monkey.
  • Skin in the game. Nassim Taleb's idea: be wary of decisions from people who don't bear their downside.
  • Guardrails beat gatekeepers. The fix is rarely "remove access". Feature flags, canary releases, reviews and rollback plans let people keep the mandate while knowledge catches up.

Ask the room

"What knowledge and validation would have been needed before that cascading change was made?" Then a show of hands: "Who has been on the receiving end of a Monkey decision this quarter?" Let the laughter land, then move on.

Likely pushback

"Managers have to make calls without knowing every detail." Agree. The pattern isn't deciding without every detail; it's deciding without enough knowledge and without paying for the outcome.

Pattern 2 · Knowledge only

💤 Coma

KMR
~75 seconds

The Coma person understands the problem perfectly and can do nothing about it. It's the quietest pattern and the most wasteful, because the expertise is already paid for.

Symptoms

Smart but sidelined; no levers and no stakes.

Impact

Slow decisions, wasted expertise, frustration, knowledge cut off from execution.

Fix

A bounded mandate and shared responsibility; prove impact through a pilot; a path from expertise to decisions.

Study notes

  • Typical trigger: a reorg or team move. The person brings the brain to the new team, but the permissions and accountability stay behind.
  • The way out runs in one direction: demonstrated knowledge earns trust, trust earns responsibility, and autonomy is the mandate that follows.
  • The fix is bounded. Not unlimited power — just enough authority to test whether the knowledge produces better results.
  • Sometimes called the "Powerless Expert". Same pattern; pick one name on the day.
  • The upside: a great source of insight. The cost: consultation without action becomes a very polite form of being ignored.

Your speech

The second pattern is "Coma". The person knows what's happening, often knows exactly what should be done, and has neither the mandate nor the responsibility to make it happen.

This is the brilliant expert who gets invited to every meeting, asked for advice, thanked warmly… and then politely ignored. They have the brain but not the keyboard. Their calendar is full; their impact is not.

Picture a developer who understands the marketplace better than anyone but can't change a thing. Or a senior engineer who moves teams and leaves their permissions behind, like luggage on the wrong flight.

The fix is a path from knowledge to action: a bounded mandate, shared responsibility, and a pilot if needed. Not unlimited power — just enough to prove the knowledge makes things better.

Examples to pull out

  • A developer who deeply understands the business domain but can't implement changes or influence decisions.
  • A senior developer moved to a new team without the permissions and accountability to use their expertise.
  • Several teams contribute to the same product page. Decisions are made verbally, dependencies surface mid-implementation, a few people become critical paths, and everything runs on personal negotiation instead of a process.

Extra input

  • The advice process. Anyone can decide, as long as they first seek advice from those affected and those with expertise. A lightweight way to turn "consulted" into "able to act".
  • Coma is sometimes self-inflicted. Commenting is risk-free; committing isn't. Invite the room to check whether they're in a Coma or just comfortable.
  • Turn knowledge into an artefact. An RFC, a decision record or a small proof of concept moves knowledge into the decision process without waiting for permission to speak.

Ask the room

"In the shared product page: which team had the knowledge, which had the authority, and who was responsible for the result?" Then: "Can the most knowledgeable person on your team actually ship the change they keep recommending?"

Likely pushback

"We can't give access to everyone with an opinion." Right — that's why the mandate is bounded and earned through a pilot.

Pattern 3 · Responsibility only

👶 Babysitter

KMR
~90 seconds

The Babysitter gets blamed for the mess but can neither understand nor control what causes it. Lean into this one if you have SRE, ops or QA people in the room.

Symptoms

Cleaning up without context or control; firefighting; repeated clean-up; defensive behaviour.

Impact

Passive operations, fragile systems, unfair pressure, risk aversion, burnout.

Fix

Grant levers (access, approvals), embed with the builders, give time to learn, connect operational responsibility to system knowledge.

Study notes

  • At best it produces passive operations ("I just restart it"); at worst, burnout.
  • It matters most for SRE and QA. An on-call engineer with no interest in understanding what they operate creates this pattern on their own. Same for QA held responsible for quality without context.
  • The "benefit" is a clear line of accountability for management. Someone is always to blame — very convenient for everyone except that someone.
  • Sometimes called the "Scapegoat". Same pattern.
  • Key nuance: an external root cause doesn't remove your ownership of detection, escalation, communication and recovery. This sets up the circle of control later.

Your speech

The third pattern is the "Babysitter". This is the person who gets called whenever something is crying, broken or on fire — but doesn't have the keys to the house.

They didn't build the system, they don't fully understand it, and they can't change what causes the problem. But it's their phone ringing at 3am. They can't stop the baby crying; they can only change the nappy. Again. And again.

Think of a developer held accountable for performance with no control over it, or someone put on call for a system they never built.

At best this creates passive operations. At worst, burnout. The fix is to make responsibility meaningful: access, approval rights and time to understand the system. If you're on call, you need enough knowledge and enough authority to actually act.

Examples to pull out

  • A developer accountable for system performance without control or understanding.
  • A developer on call for a system they didn't build and don't understand.
  • An SRE team operating a system without taking time to understand it; a QA team responsible for quality without context.
  • A shipping partner goes down overnight. Alerts fire, but nobody sees them until morning and parcels pile up. The cause was external — but detection, escalation, customer communication and the fallback plan were still ours.
  • An email provider slows down and verification codes arrive late, so password resets and logins fail. Again external — but monitoring customer impact and deciding what to switch off was still ours.

Extra input

  • Google's SRE practice caps operational work at 50% of an engineer's time; the rest goes to engineering that removes the toil. A concrete way to stop babysitting and start fixing.
  • Error budgets give the on-call side a lever: when the budget is spent, feature releases pause. Responsibility becomes mandate.
  • Runbooks aren't knowledge transfer. A runbook says what to click, not why the system fails. Pairing and shadowing the builders do.

Ask the room

"If the cause is external, who still owns the customer impact and recovery?" (Answer: we do — let them get there.) Then: "Who's on call for something they couldn't draw on a whiteboard?"

Likely pushback

"Someone has to cover legacy systems nobody understands." True. Then that rotation needs time budgeted to learn and improve them; otherwise you're funding burnout.

Pattern 4 · Mandate + Knowledge, no Responsibility

🧒 Teenager

KMR
~1 min card + 3 min example

The Teenager can act and understands the system, but waits for someone else to own the outcome. Most teams will quietly recognise themselves here, so deliver it warmly.

Symptoms

Autonomy without consequences; finger-pointing; waiting for someone else to prioritise; risky bets.

Impact

Loss of trust, unresolved problems, and eventually the mandate is taken back.

Fix

Tie decisions to SLAs and OKRs, add on-call, make incident accountability explicit, expect the team to act in its own domain.

Study notes

  • The danger is the end state: when a team won't own outcomes, leadership revokes the mandate. Teenager today, Coma or Babysitter tomorrow. Say this — it gives the pattern teeth.
  • The example isn't about recklessness, it's about passivity: the team saw the problem, had the skills, and waited for the PM to make it official. Avoiding responsibility often looks like politeness to the process.
  • What separates it from the Foot soldier: could the team have acted? If yes, Teenager. If they truly lacked access or approval, Foot soldier.

Your speech

The fourth pattern is the "Teenager". The team knows what it's doing and has enough authority to act. What it doesn't want is the responsibility that comes with that authority.

They want the driving licence, not the parking ticket. They'll happily borrow the car; they'll be less available when it comes back with a dent.

Here's one. In a weekly business review, a team spots a problem with its tracking metrics. They know what's wrong, they could fix it — and they wait for the PM to prioritise it. Meanwhile a senior leader from outside the team steps in and starts fixing it on the spot. In front of everyone. The professional equivalent of your mum tidying your room while your friends are over.

The team had the knowledge and could have acted. It didn't show agency in its own area; it waited for someone to make the problem official.

The fix is to connect decisions to outcomes: SLAs, OKRs, on-call, incident accountability. And one simple rule: if the problem is clearly in your domain, you act. You don't wait for someone to prioritise reality.

Examples to pull out

  • The tracking-metrics story from the speech. Why it's broken: the team relied only on the PM's prioritisation and missed the stakeholders' priority. How to fix it: understand stakeholder needs and look at the impact of system gaps beyond the roadmap.
  • The shared product page, revisited: several teams could contribute, but nobody clearly owned the intersection between them.

Extra input

  • The bystander effect. The more people see a problem, the less likely any one of them acts. A weekly business review is the perfect habitat for Teenagers: twenty people saw the broken metric.
  • Extreme Ownership (Jocko Willink and Leif Babin): own everything in your world, including the things you didn't break.
  • A phrase to give the room: "I've got this — here's what I'm doing and when you'll hear from me." Saying it out loud is half the fix.

Ask the room

"Where do we have teams that can act and understand the problem, but still wait for someone else to take responsibility?" Braver version: "When did your team last wait for permission it didn't actually need?"

Likely pushback

"But the PM owns prioritisation." The PM owns the roadmap; the team owns the health of its domain. A broken metric in your system isn't a feature request.

Pattern 5 · Responsibility + Knowledge, no Mandate

🪖 Foot soldier

KMR
~1 min card + 3 min example

The Foot soldier understands the system and answers for the outcome, but can't pull the levers to fix it. Expect the most nodding here; it's the pattern people feel most.

Symptoms

Experts handle incidents but can't change things; repeated escalation; dependence on other teams.

Impact

Burnout, "management by escalation", poor customer outcomes, decisions made without the expertise.

Fix

Delegate change rights, access, approvals, time and budget to those responsible; give the domain team control of its system.

Study notes

  • "Management by escalation" is the tell: the only way to get anything done is to go up the chain, so managers become human routers.
  • There's an ask of the team too, not just of leadership: claim the mandate (or full ownership) and show agency instead of accepting slow approval processes. The Foot soldier's way out still starts with the Foot soldier.
  • Don't let this become a complaint session about other teams. That's the circle of concern. Frame it as: what's the case we'd make to get the mandate?

Your speech

The fifth pattern is the "Foot soldier". This person knows the system and is responsible for the result, but can't change the things that need changing.

They're on the hook — but the hook is attached to someone else's wall.

Here's the example. A team needs to configure a third-party tool for customer-facing notifications. That configuration affects customer satisfaction, and the team understands the impact. But to change it, they need approval from another team that doesn't know the domain and doesn't feel the impact. So the people with the most context fill in a ticket and wait, and the people with the authority approve something they don't fully understand.

The result: slow decisions, endless escalation and tired experts. The fix is to delegate access, approvals, change rights, time and budget to the people who are responsible. And for the team: don't just accept the queue. Make the case and claim the mandate over what affects your domain.

Examples to pull out

  • The notification tool from the speech, gated by a team with no domain knowledge.
  • An identity sync touched by several teams, where nobody is sure who owns the sync logic, where the boundaries are, or who to escalate to.
  • A team that depends heavily on one external provider, with no fallback it's allowed to switch on.
  • An on-call engineer who has to decide whether to disable a security feature during an incident, with no monitoring that shows the impact and no authority to switch provider.

Extra input

  • Delegation levels (Management 3.0 "delegation poker"): tell, sell, consult, agree, advise, inquire, delegate. "We have the mandate" is vague; "we're at level 6 for notification config" is not.
  • Break-glass access. A documented, audited emergency path gives on-call people the mandate when it matters, without permanent broad access. Pairs directly with quiz scenario 7.
  • Conway's law. Systems mirror the organisation's communication lines. If an approval crosses two teams, expect a seam in the system right there.

Ask the room

"Where are we holding a team responsible for an outcome while another team controls the access, approval or configuration?" Then: "How many approvals does your most common change need — and do the approvers know the domain?"

Likely pushback

"Approvals exist for compliance or security." Some do, and those stay. The question is whether the approver has the context. If not, move the approval or give them the context.

Pattern 6 · Mandate + Responsibility, no Knowledge

🎲 Gambler

KMR
~1 min card + 3 min example

The Gambler can decide and will pay for the outcome, but bets on gut feeling instead of evidence. It's the best one to finish on, because it leads straight into "how to fix it".

Symptoms

Gut decisions, partial data, developers kept away from operations, weak builder–operator communication.

Impact

Costly incidents, missed deadlines, productivity drag, trust breakdown, poor trade-offs.

Fix

Shared knowledge: joint post-mortems, golden metrics, pairing with experts, evidence for scope changes.

Study notes

  • "They don't know what they don't know." The bet feels safe because the risk is invisible.
  • The root is often a broken channel, for example between SRE and developers. Each side holds half the knowledge; nobody holds the full picture when the decision is made.
  • The point of the example: acting isn't the problem — acting without evidence is.
  • Gambler vs Monkey: same missing knowledge, but the Gambler pays. That's good news — the incentive to learn is already there.

Your speech

The sixth pattern is the "Gambler". The team can make decisions and will carry the consequences. What it lacks is enough understanding, or enough evidence, to decide well.

This is where the organisation starts playing roulette with production. Except the chips are customer trust, revenue and delivery dates. And the house always wins.

The example: a business team insists on adding an unvalidated feature to an MVP, because partners "might stop using the platform" without it. The team says yes, adds the feature and misses the original deadline. Notice the word "might". Nobody asked how many partners, how likely, or how much.

The problem isn't that the team acted. Acting is good. The problem is that it didn't ask for data, didn't validate the claim, and didn't compare the partner impact with the cost of being late.

The fix is shared knowledge: post-mortems with developers and operators, golden metrics, pairing with experts — and one habit above all: when the request is urgent, ask for the evidence behind it.

Examples to pull out

  • The unvalidated MVP feature from the speech. How to fix it: clear criteria for scope changes, evidence for last-minute additions, and owning the timeline by pushing back on unvalidated requirements.
  • A fee rule meant for one product segment gets applied to all of them because a configuration was missing. A human spots it more than a day later.
  • A security fix starts rate-limiting legitimate logins; sign-ups quietly drop, and it's only noticed manually the next day.
  • A viral social post sends a traffic spike. Aggressive timeouts plus retries create a retry storm, and checkout falls over. Detection was quick; diagnosis needed deep system knowledge.

Extra input

  • One-way vs two-way doors (Jeff Bezos): reversible decisions can be made fast on gut; irreversible ones deserve evidence. A Gambler treats every door as two-way.
  • The four golden signals (Google SRE): latency, traffic, errors, saturation. Several of the examples above were caught by humans after a day; golden signals shorten that.
  • A question for scope changes: "What would we need to see to know this is true?" Polite, hard to argue with, and it turns "might" into a number.

Ask the room

"Where do we have authority and responsibility, but not enough system knowledge or evidence to make a safe decision?"

Likely pushback

"We can't wait for perfect data." Agreed. Ask for proportionate evidence: more for one-way doors, less for two-way ones.

After the break

How to fix it

The fix is always the same three steps: diagnose the missing element, add it with the lightest intervention, and check that it worked.

  1. Diagnose. Which element is missing — knowledge, mandate or responsibility?
  2. Pick one fix, the lightest that works. Missing knowledge: pairing, mentoring, documentation, monitoring, post-mortems. Missing mandate: access, decision rights, approval rights, budget, time. Missing responsibility: an explicit owner, an SLA, on-call duty, incident follow-up.
  3. Close the loop. Look for fewer escalations, less manual work, faster and safer changes, fewer open incidents, follow-up actions actually closed.

Quote the real pulse-check result when you get here ("so 30% of us live with Monkeys…"). It makes the next part personal.

Closing speech

When something goes wrong, the instinct is to ask who's to blame. I'd like you to leave today with a different question: which element is missing — knowledge, mandate or responsibility? Then add it, and check the result.

The short version: the Monkey can act. Coma can understand. The Babysitter gets blamed. The Teenager avoids responsibility. The Foot soldier is blocked. The Gambler acts without knowing enough.

And remember: this is ownership you practise, and ownership you can demand from others. It's only complete when all three come together. Anything less is a pattern — and now you know their names.

Facilitator key

Quiz scenarios

The first answer is the one the slides reveal. Several are deliberately debatable; when the vote splits, ask each side which element they think is missing.

1Team A depends on Team B's domain in the monolith. Instead of helping Team B extract it, Team A starts working directly in the monolith to move faster.
Teenager

Team A exercises mandate in someone else's domain without the responsibility that comes with it, leaving boundary violations and debt behind. Also defensible: Monkey with a gun, if Team A lacks the domain knowledge too. Action: help Team B extract the domain; agree explicit boundaries and Team B reviews.

2An expert in a configuration stack moves to a new team. That team depends on the old one but has no ownership over the configuration domain.
Coma

The knowledge travelled; mandate and responsibility stayed behind. Action: a bounded mandate or pilot, or move domain ownership along with the expertise.

3You just joined a team whose manager is about to leave. Before leaving, they make a decision that will significantly shape the team's future.
Teenager

Mandate without responsibility: the departing manager won't face the consequences, and from your seat you become the Babysitter. Also defensible: Monkey with a gun. Action: ask for the reasoning and assumptions in writing; escalate if the decision is irreversible.

4A bug in your team's code goes undetected for a week. By the time it's caught, orders in one market have dropped significantly.
Gambler

The team owns and ships the code but lacks the knowledge (monitoring, golden metrics) to see its impact. Action: business-level alerts, golden metrics, and a post-mortem with owned actions.

5Your team has five post-mortem action items past their SLA. Nobody is driving them to closure.
Babysitter or Teenager

Babysitter if the team is stuck without the mandate to fix the root causes; Teenager if it could close them and simply doesn't own the outcome. Action: a named owner per action, reviewed in a recurring ritual.

6Your team's intern has had production deployment rights since day one.
Monkey with a gun

Mandate before knowledge or responsibility. Action: keep the rights only with guardrails — reviews, CI, feature flags, a buddy. Good debate: is it the access or the missing guardrails?

7You're paged at 2am. You find the fix quickly, but you don't have deploy access and there's no escalation path. So you go back to sleep.
Foot soldier

Knowledge and responsibility, no mandate — and going back to sleep slides into Teenager. Action: break-glass access and a clear escalation path. Tonight: wake someone up.

On the day

Facilitation tips

  • Use the room's words. When someone says "that's so us", reuse their example in the next pattern.
  • Watch for blame. If it turns into "team X is a Monkey", redirect: "Which element is missing, and what could we do from our circle of influence?"
  • Protect the clock. The six patterns can easily eat 40 minutes. "Let's take that into the exercise" is your friend.
  • Go first. Admit which pattern you've lived yourself (the Teenager is a safe, relatable pick). It gives everyone else permission to be honest in the pulse check.

Second screen

Cheat sheet

PatternMissingFix in five words
🔫 Monkey with a gunKnowledge, ResponsibilityDecider joins the incident bridge
💤 ComaMandate, ResponsibilityBounded mandate, prove via pilot
👶 BabysitterKnowledge, MandateAccess, approvals, time to learn
🧒 TeenagerResponsibilityYour domain, you act first
🪖 Foot soldierMandateDelegate rights to the responsible
🎲 GamblerKnowledgeAsk for the evidence first

Shortest memory version

The Monkey can act. Coma can understand. The Babysitter gets blamed. The Teenager avoids responsibility. The Foot soldier is blocked. The Gambler acts without knowing enough.

References

  • Alex Ewerlöf, Broken ownership — the six archetypes this guide is built on.
  • Stephen Covey, The 7 Habits of Highly Effective People (1989) — the Circle of Concern and Circle of Influence behind the circles of control, influence and concern used after the break.
  • Werner Vogels on "you build it, you run it" (2006); Nassim Taleb, Skin in the Game; Google, Site Reliability Engineering; Management 3.0 delegation poker; Jocko Willink and Leif Babin, Extreme Ownership.