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
Brand wants rounder corners. The system designer agrees. An engineering lead worries about layouts. A product director wants to wait until after a launch.
Nobody knows who decides. The topic comes up in five meetings over three months. Everyone's frustrated; nothing happens.
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
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.
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:
| Model | How it works | Strengths | Breaks when… |
|---|---|---|---|
| Embedded | Product designers and engineers look after it part-time | Cheap; close to real needs | More than about three squads depend on it |
| Centralised | A dedicated team builds and runs it for everyone | Focus, quality, clear accountability | Requests outpace the team; teams feel unheard |
| Federated only | Every team contributes; nobody owns it full-time | Shared ownership; broad input | Almost immediately, without strong leadership |
| Hybrid | A core team owns quality and direction; product teams contribute | Scales; balances quality and speed | Contribution time isn't protected in product plans |
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.
| Decision | Decides | Can block | Consulted |
|---|---|---|---|
| Design principles | Head of Design | — | System lead, design leads |
| Foundations (colour, type, spacing) | System lead | Brand (brand values only) | System and product designers, engineering |
| Token names and structure | System engineering lead | — | System designers |
| Token value changes | System lead | Accessibility specialist (contrast) | Champions |
| Component architecture and API | System engineering lead | — | System designers, product engineers |
| Component design | System design lead | Accessibility specialist | Requesting teams |
| Patterns | Pattern owner (often a senior product designer) | System design lead | Teams using the pattern |
| Accessibility standard | Accessibility lead | Heads of Design and Engineering | Legal / compliance |
| Breaking changes and release timing | System lead | — | Champions, affected teams |
| Deprecation and removal | System lead | — | Affected teams |
| Exceptions to system rules | System design or engineering lead | — | Requesting team |
| Roadmap and funding | Design and engineering leadership | — | System lead, product leads |
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 type | Examples | Process | Time |
|---|---|---|---|
| Everyday | Bug fixes, docs, small enhancements, new variants | The owner decides, in review | Days |
| Significant | New components, token value changes, new patterns, deprecations | Short written proposal; one-week comment period; decider decides | 1–2 weeks |
| Foundational | New framework, library-wide breaking change, new brand, accessibility standard | Proposal; wider comment period; leadership or council review | 2–6 weeks |
| Exception | Breaking a rule for one product | Short request; named approver; expiry date; logged | Days |
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.
The owner decides
The person with decision rights makes the call after hearing the concerns. Most disagreements end here.
System lead
If someone believes the decision is wrong for the system as a whole.
Design and engineering leads together
For conflicts between design and engineering, or between product teams.
Council or leadership
Only for decisions affecting several business units or company direction.
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.
| Gate | Standard | Checked by |
|---|---|---|
| Accessibility | WCAG 2.2 AA minimum for every component and pattern | Automated checks plus manual review |
| Tokens only | No raw colours, sizes or spacing in system code | Lint rules |
| Visual change | No unintended visual differences | Visual regression tests plus designer sign-off |
| Design and code in step | Figma and code match in names, props and states | Definition of done |
| Versioning | Semantic versioning, including visual breaking changes | Release review |
| Documentation | Every public component has a complete page | Build check for missing docs |
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:
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.
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.
Governance by company size
Governance should grow with the organisation, never ahead of it.
| Startup | Scale-up | Mid-sized | Enterprise | |
|---|---|---|---|---|
| Who decides | The two owners, in conversation | System lead; decisions written down | Decision-rights matrix | Matrix plus a council for cross-portfolio decisions |
| Proposals | A message in the channel | One page for big changes | Proposals with comment periods | Per portfolio plus central review |
| Records | Pinned messages | Simple decision log | Log plus ownership registry | Same, plus an audit trail |
| Gates | Code review | Lint plus review | Automated gates plus release review | Plus compliance sign-off where required |
| Escalation | Talk it out | Lead → design/eng lead | Full path | Full path plus council |
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
- A Design System Governance ProcessBrad Frost. A widely used starting point.
- Team Models for Scaling a Design SystemNathan Curtis, EightShapes. Centralised, federated and hybrid.
- The Fallacy of Federated Design SystemsNathan Curtis. Why "everyone owns it" rarely works.
- GOV.UK contribution criteriaPublished criteria for what gets into a system.
- CARS24: how the design system team stopped being the bottleneckOne front door, a 70-point scorecard and three ownership tiers.
