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 company examples address different forms of accountability:
- 37signals emphasizes “managers of one” — individuals are expected to direct their own work without waiting for an assignment. (Source)
- GitLab defines the DRI (Directly Responsible Individual) — a named person is accountable for the success or failure of the assigned project. (Source)
- Zapier emphasizes defaulting to action and working in public. Its async guide supports those behavioral norms; it does not establish a universal DRI definition or mandatory single-page project specification. (Source)
These examples distinguish self-direction, formal project accountability and communication norms; their names and responsibilities are not interchangeable.
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. GitLab defines a DRI’s accountability for the assigned project. This makes the owner and scope of responsibility explicit. Its separate individual-contributor career path supports seniority without requiring a management role. (DRI guidance, structure)
Shopify — Human decision ownership in an AI workflow. Shopify’s September 2026 River account describes investigations that retain context during handoffs, while engineers retain authority over risk decisions, review and merges. [Inference — application guidance.] Assign authority for the decision, not just responsibility for preparing the work. (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.
Related Frameworks
- Sync vs Async Decision Matrix — choose a communication mode for the work
- The 20–30 Person Fracture Point — a working hypothesis about coordination needs during growth
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 — How to Work Asynchronously: https://zapier.com/blog/how-to-work-asynchronously
- Expectations — Automattic: https://automattic.com/expectations/
Shopify — River security remediation (September 2, 2026): https://shopify.engineering/river-vulnerability-remediation
GitLab — Directly Responsible Individuals: https://handbook.gitlab.com/handbook/people-group/directly-responsible-individuals/
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.
- Self-direction and formal decision ownership may reinforce each other, but a manager-of-one philosophy does not by itself establish a DRI assignment or its decision rights.
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.