Book a call

WritingGovernancePart 3 of 4 in The operating model

Design system governance: who decides what, and how

Good governance isn't a committee. It's what lets most decisions happen quickly, by the right person, without a meeting. A decision-rights matrix, processes matched to the size of the decision, an escalation path and a decision log.

On this pageWhat design system governance is, and isn't
  1. What design system governance is, and isn't
  2. Why governance fails
  3. Centralised, federated and hybrid models
  4. Decision rights: who has the final say
  5. Matching the process to the decision
  6. When people disagree: the escalation path
  7. Standards and quality gates
  8. The component lifecycle
  9. The decision log
  10. Governance by company size
  11. The short version
  12. Frequently asked questions
  13. Further reading

The short answer

Design system governance is the agreed way decisions about the system get made: who decides what, how, how fast, and how it's recorded. Good governance is light. It lets most decisions happen quickly, by the person closest to the work, and slows down only for the few that affect everyone. Its core parts are a decision-rights matrix, processes matched to the size of each decision, an escalation path, automated quality gates and a decision log.

  • One decider per kind of decision. "The team decides" means nobody does.
  • Give accessibility a real veto: someone who can block a change that fails the standard.
  • Grow governance with the organisation, never ahead of it.

What design system governance is, and isn't

Governance has a bad reputation, because people picture committees and approval forms. Good design system governance is the opposite: it's what lets a token change, a new variant or a deprecation happen in days rather than drift for months.

An illustration: three months to change a border radius

The situation

Brand wants rounder corners. The system designer agrees. An engineering lead worries about layouts. A product director wants to wait until after a launch.

What goes wrong

Nobody knows who decides. The topic comes up in five meetings over three months. Everyone's frustrated; nothing happens.

What governance changes

Token changes are decided by the system lead after a one-week comment period. The engineering concern becomes a release plan; the launch sets the date. Decided in ten days and logged with reasons.

Brad Frost's widely used governance process makes the same point a different way: most work should flow through a clear, predictable path from "use what's there" to "propose a change" to "release", with the system team and product teams each knowing their part. Governance is that path, plus clarity about who decides at each step.

Why governance fails

TOO LITTLE

Nobody decides

Decisions are re-opened in every meeting. The loudest team gets its way. Components fork because changing the original is too uncertain. Quality drifts because nobody can say no.

TOO MUCH

Everything waits

Every change goes to a monthly council, so everything takes a month. Teams stop asking and build locally. The system becomes something to work around.

The aim is the narrow path between them: fast for small, reversible decisions; careful for big, hard-to-undo ones.

Centralised, federated and hybrid models

Governance depends on how the system is staffed. Nathan Curtis's team models are still the clearest way to describe the options:

ModelHow it worksStrengthsBreaks when…
EmbeddedProduct designers and engineers look after it part-timeCheap; close to real needsMore than about three squads depend on it
CentralisedA dedicated team builds and runs it for everyoneFocus, quality, clear accountabilityRequests outpace the team; teams feel unheard
Federated onlyEvery team contributes; nobody owns it full-timeShared ownership; broad inputAlmost immediately, without strong leadership
HybridA core team owns quality and direction; product teams contributeScales; balances quality and speedContribution time isn't protected in product plans
Curtis's own later conclusion is the one most mature organisations reach: a central team plus participation from a wider community.

Decision rights: who has the final say

The single most useful governance artefact is a table that says, for each kind of decision, who decides. Here's one for a hybrid system at a mid-sized company. "Decides" is accountable for the final call; "can block" may veto; "consulted" must be asked first. Rename the roles for your organisation, but keep one decider per row.

DecisionDecidesCan blockConsulted
Design principlesHead of Design—System lead, design leads
Foundations (colour, type, spacing)System leadBrand (brand values only)System and product designers, engineering
Token names and structureSystem engineering lead—System designers
Token value changesSystem leadAccessibility specialist (contrast)Champions
Component architecture and APISystem engineering lead—System designers, product engineers
Component designSystem design leadAccessibility specialistRequesting teams
PatternsPattern owner (often a senior product designer)System design leadTeams using the pattern
Accessibility standardAccessibility leadHeads of Design and EngineeringLegal / compliance
Breaking changes and release timingSystem lead—Champions, affected teams
Deprecation and removalSystem lead—Affected teams
Exceptions to system rulesSystem design or engineering lead—Requesting team
Roadmap and fundingDesign and engineering leadership—System lead, product leads
A decision-rights matrix. Practitioner view Decisions are pushed down to the people closest to the work; leadership decides only direction and money.

Notice the accessibility veto. It's deliberate: accessibility is the one area where "we'll fix it later" multiplies harm across every product that uses the system.

Matching the process to the decision

Not every decision needs the same process. Ask two questions: how many people does this affect, and how easy is it to undo?

Decision typeExamplesProcessTime
EverydayBug fixes, docs, small enhancements, new variantsThe owner decides, in reviewDays
SignificantNew components, token value changes, new patterns, deprecationsShort written proposal; one-week comment period; decider decides1–2 weeks
FoundationalNew framework, library-wide breaking change, new brand, accessibility standardProposal; wider comment period; leadership or council review2–6 weeks
ExceptionBreaking a rule for one productShort request; named approver; expiry date; loggedDays

The comment period matters as much as the decision. People accept decisions they disagree with far more readily when they had a genuine chance to be heard and the reasons are written down.

When people disagree: the escalation path

Disagreement is healthy; endless disagreement isn't. Publish an escalation path, with time limits, so nobody has to invent one in the middle of an argument.

1

The owner decides
The person with decision rights makes the call after hearing the concerns. Most disagreements end here.

days
2

System lead
If someone believes the decision is wrong for the system as a whole.

within a week
3

Design and engineering leads together
For conflicts between design and engineering, or between product teams.

within two weeks
4

Council or leadership
Only for decisions affecting several business units or company direction.

next session
Four steps, each with a time limit. Once a decision is made through the agreed process, everyone commits to it, including those who argued against it. They can propose revisiting it later, with new evidence, through the same process.

Standards and quality gates

Some things shouldn't be decided case by case. They're standards, applied as gates every change passes through. The more gates are automated, the less governance needs people's time.

GateStandardChecked by
AccessibilityWCAG 2.2 AA minimum for every component and patternAutomated checks plus manual review
Tokens onlyNo raw colours, sizes or spacing in system codeLint rules
Visual changeNo unintended visual differencesVisual regression tests plus designer sign-off
Design and code in stepFigma and code match in names, props and statesDefinition of done
VersioningSemantic versioning, including visual breaking changesRelease review
DocumentationEvery public component has a complete pageBuild check for missing docs
In practice

At JPMorgan Chase, governance is partly automated: two checkers point out where a Figma file or a piece of code doesn't match the design system, so problems are fixed before review, for a community of 500+ designers and 1,000+ engineers. See the project. At IBM, the Riyadh Air system used four quality gates between a request and a release, shared by three companies. Read the case study.

The component lifecycle

Governance also covers how parts enter and leave the system. A simple set of labels, shown on every documentation page, tells teams what they can rely on:

ProposedRequest accepted; being designed with a pilot team
→
BetaUsable, API may still change; feedback wanted
→
StableSupported; breaking changes only in major versions
→
DeprecatedReplacement named; removal date announced
→
RemovedGone in the next major version, with a migration guide

The decision log

Two simple records make governance trustworthy: a decision log that records what was decided and why, and an ownership registry that lists who owns each component, pattern and token group. The log stops decisions being re-litigated and gives newcomers the history behind the system.

DS-042 · DECIDED 2 OCTOBER BY THE SYSTEM LEAD

Increase default button height from 36px to 40px

Context. Research showed buttons were hard to hit on touch laptops; 36px is below our comfortable-target guideline.

Options. (a) Patch release now · (b) A new "large" default only for new work · (c) A breaking change in 5.0, with notice.

Decision. (c), shipping in 5.0 on 18 November, with visual diffs and a layout checklist.

Consulted. Champions in every team, engineering leads, accessibility specialist. Concern about table rows addressed with a compact variant.

Revisit if. More than two teams report blocking layout problems during the beta.

A decision log entry. Illustration Six short fields; the "revisit if" line is what makes people comfortable committing.

Governance by company size

Governance should grow with the organisation, never ahead of it.

StartupScale-upMid-sizedEnterprise
Who decidesThe two owners, in conversationSystem lead; decisions written downDecision-rights matrixMatrix plus a council for cross-portfolio decisions
ProposalsA message in the channelOne page for big changesProposals with comment periodsPer portfolio plus central review
RecordsPinned messagesSimple decision logLog plus ownership registrySame, plus an audit trail
GatesCode reviewLint plus reviewAutomated gates plus release reviewPlus compliance sign-off where required
EscalationTalk it outLead → design/eng leadFull pathFull path plus council
A mistake we see often

A council for everything. Councils meet monthly, so everything takes a month. Keep the council for the handful of decisions that genuinely cross business units, and let the decision-rights matrix handle the rest.

Governance is one part of a wider operating model. For how requests and contributions flow into these decisions, see the contribution model; for team structure and rituals, see the design system operating model.

The short version

  • Governance makes most decisions fast and slows down only the few that affect everyone.
  • Write down one decider for each kind of decision, and give accessibility a real veto.
  • Match the process to the impact, publish an escalation path, and expect everyone to disagree and commit.
  • Automate standards as gates; keep a decision log and an ownership registry.
  • Grow governance only as you grow.

Frequently asked questions

What's the difference between centralised and federated governance?

In a centralised model a dedicated team makes and builds the decisions. In a federated model, contributors across product teams do, with no full-time owner. Most mature systems end up hybrid: a core team owns quality and direction, and product teams contribute.

Who has the final say on a design system?

It depends on the decision. The system lead usually decides foundations, breaking changes and deprecations; the engineering lead decides architecture and token structure; leadership decides roadmap and funding. Write it down in a decision-rights matrix.

How do you stop governance slowing teams down?

Match the process to the size of the decision, automate standards as gates, and keep councils for genuinely cross-company decisions. Everyday changes should be decided by the owner in review, in days.

How should we handle teams that detach or fork components?

Treat it as a signal, not a crime. Track detaches, ask why, and either improve the component or offer an exception with an expiry date. Persistent forking usually means requests are too slow.

Do small teams need governance?

A little: two named owners, decisions written in the channel, and code review as the gate. That's governance too, and it's enough until there are more teams than the owners can talk to.

Further reading