What It Is
Decision ownership is the principle that every significant decision, project, or initiative has a single person who is accountable for it — not a team, not a committee, not “shared leadership.” One person owns it. They gather input, weigh the options, make the call, and are responsible for the outcome.
The implementations vary:
- 37signals calls it “managers of one” — every individual owns their own work and direction without needing a manager to assign it. (Source)
- GitLab calls it DRI (Directly Responsible Individual) — every project and decision has a named single owner. (Source)
- Zapier uses DRIs with a similar definition — named single owner, explicitly accountable. (Source)
- Automattic’s “be brave” norm instructs individuals to move forward on decisions rather than wait for consensus. (Source)
The concept is consistent across companies regardless of the name used.
Why It Works
In remote settings, diffuse ownership is invisible. In a colocated office, a task without a clear owner eventually becomes visible to someone who picks it up. In a distributed, async environment, an ownerless task can go weeks without progress and nobody knows — because nobody is watching. Decision ownership makes accountability explicit and visible without requiring surveillance. [Inference — central observation supported by the operating documentation at the cited companies but not measured cross-company.]
Committees produce decisions by subtraction. When a group “owns” a decision, the decision gravitates toward whatever the least controversial option is — not the best option. Decision ownership frees the accountable person to make the best call, then defend it to stakeholders, rather than pre-optimize for group approval. [Inference — practitioner observation; a recurring pattern in the failure modes the cited companies describe, not a measured finding.]
Single ownership speeds up decisions. When it is clear who decides, the decision-making process is: gather input, deliberate, decide. When it is unclear who decides, the process is: gather input, debate, negotiate, repeat, eventually default to the most persistent voice. [Inference — corollary of the diffuse-ownership claim above; same evidence basis.]
It creates clarity about what is happening and why. When every project has a named owner, anyone in the company can find out who to talk to about any piece of work. The DRI is the canonical source of truth for their project. This is especially valuable in async environments where information does not flow through proximity.
Where It Fails
Single ownership requires authority to match responsibility. A DRI who is accountable for a decision but does not have authority over the inputs (budget, engineering capacity, design resources) produces frustration, not decisions. Decision ownership only works when the owner can actually act.
“Manager of one” breaks down at the edges of individual competence. 37signals’ model — every person directs their own work — works beautifully for highly competent self-directed people. It breaks for people who are new, confused, or genuinely need direction. DHH acknowledges this directly: poor performance cases bubble up to the founders. (Source)
DRIs become bottlenecks if overloaded. When a single person owns too many decisions simultaneously, they become the organizational chokepoint. Decision ownership requires limiting each person’s simultaneous ownership scope. [Inference — practitioner observation; not measured but a recurring failure mode in DRI implementations.]
Shared decisions are real. Some decisions genuinely affect multiple domains and require multiple perspectives before action. Forcing a single DRI on a genuinely cross-functional decision does not eliminate the need for coordination — it just moves it to a different phase.
Best Examples
37signals / Basecamp — Managers of One. The hiring and management philosophy: every person at 37signals is expected to “set their own direction when one isn’t given” and determine “what needs to be done, and do it, without waiting for someone to tell you to.” The entire manager-less operating model rests on this — if people cannot own their own work, the model fails. (Source)
GitLab — DRI System. Explicitly named. Every project has a DRI listed. The DRI is responsible for moving the project forward, for making the calls within their scope, and for escalating when needed. Single-page project specs name the DRI at the top. The dual career path for individual contributors (as senior as VPs) gives ICs real authority without requiring management roles. (Source)
Zapier — DRI + Single-Page Specs. Every significant project starts with a single-page spec naming the DRI and defining the goal, success criteria, and key decisions. The DRI is accountable from spec through completion. “Default to action” is the cultural value that operationalizes this: do not wait for someone to give you permission when you have clear ownership. (Source)
Implementation Guide
1. Name a DRI for every significant project. Put the name in the project doc, the issue, the kickoff announcement — wherever the project lives. The DRI should be obvious to anyone who encounters the project.
2. Define what DRI means in your context. Does the DRI make all decisions? Or make recommendations that a manager approves? The role needs a clear definition. “DRI” without a definition is just a label.
3. Give the DRI real authority. If someone owns the decision but has to get approval for every resource allocation, they are not a DRI — they are a coordinator. Real ownership requires real authority over the relevant inputs.
4. Limit simultaneous ownership. A DRI who owns 15 active projects is accountable for 15 things they cannot give adequate attention to. Establish norms for how many ownership roles one person should hold at a time.
5. Hire and promote for ownership capacity. “Manager of one” is a trait that can be evaluated at hire: does this person set their own direction, decide without excessive confirmation-seeking, and take responsibility for outcomes? Make it a deliberate hiring criterion.
6. Build escalation paths. Decision ownership works until the DRI hits a decision they are not equipped to make alone. There must be a clear path to escalate — and it must be used without penalty. At 37signals, hard cases go to the founders. At GitLab, they move up the manager hierarchy.
Common Mistakes
Using DRI as a way to blame someone rather than empower them. Decision ownership is a tool for clarity and speed. When organizations use it to assign blame for failures without giving people real authority, it becomes a liability rather than an empowerment model.
Assigning ownership to teams, not people. “The product team owns this” is not decision ownership. Teams do not make decisions — people do. Name a person.
Confusing input-gathering with shared ownership. The DRI should gather input from stakeholders — that is good process. But gathering input is not the same as sharing ownership. The DRI still makes the call. Confusing this leads to de facto committee decisions wearing a DRI label.
Not revisiting ownership as scope changes. A project that starts as one person’s responsibility often grows into something that affects multiple domains. When scope changes, ownership should be revisited explicitly — not just inherited by the original DRI.
Sources
- DHH: We once more have no full-time managers at 37signals: https://world.hey.com/dhh/we-once-more-have-no-full-time-managers-at-37signals-f8611085
- 37signals Handbook: How We Work: https://basecamp.com/handbook/how-we-work
- GitLab Organizational Structure: https://handbook.gitlab.com/handbook/company/structure
- Zapier CEO Wade Foster on Working Async: https://remote.com/blog/remote-work/remote-talks-episode-5-wade-foster
- Expectations — Automattic: https://automattic.com/expectations/
Inferences
- Decision ownership solves a coordination problem that is invisible in colocated companies but becomes critical in remote ones. In an office, work without a clear owner usually gets noticed and resolved informally. Remotely, ambiguous ownership produces silent failure — work that nobody is moving forward, decisions that nobody is making, problems that nobody surfaces until they have become crises. Decision ownership is the structural fix for this failure mode.
- The “manager of one” model and the DRI model are the same principle at different levels. Managers of one describes the individual’s relationship to their own work. DRI describes the individual’s relationship to a specific project or decision. The underlying principle — one person, clear accountability, real authority — is identical.
Work with Alex
If your company has too many projects that “everyone owns” and therefore nobody owns, Alex helps leadership teams build the ownership clarity that allows distributed execution to move.