Governance: Who Decides How a Design System Changes
The agreed rules, roles, and review steps that keep a design system consistent and trusted as it grows.
In short
Governance is the agreed rules, roles and review steps that decide how a design system changes, keeping it consistent and trusted as it grows.
13 min readFree
What you will learn
A design system is a shared set of parts and rules that many teams use. Governance is the set of agreed rules and roles that decide how that system changes, who may change it, and how each change is checked and shared. This lesson explains who owns what, how a change moves from a request to a release, and how changes are announced and kept up to date. By the end you should be able to explain why a design system needs governance and describe a simple process it could follow.
Key words
- Governance
- The agreed rules and roles that control how a design system is changed, reviewed, and shared.
- Core team
- The small group that looks after the whole design system day to day.
- Contributor
- Anyone who suggests or builds a change, such as a designer working on a product.
- Approver
- The person or group who makes the final yes or no decision on a change.
- Decision rights
- The record of who is allowed to make which kind of decision.
- Operating model
- The way control and work are split between a central team and product teams.
- Versioning
- Giving each release a number so people can see how big the change is.
- Deprecation
- Marking a part as old, with a warning and an end date, before it is removed.
- Migration guide
- Step-by-step notes that help teams move from an old part to a new one.
- Adoption
- How many teams actually use the current version of a part.
What does governance mean here?
Without governance, every team changes the shared parts to suit its own needs. A button gets a new colour in one product, a new corner shape in another, and after a year nobody knows which one is correct. The system stops being shared at all.
Good governance does not mean slow or strict for its own sake. Its purpose is to keep the system consistent and trusted while it grows. A team should be able to trust that a part it uses today will still work next year, and that every new part was checked before anyone else started to rely on it.
Who owns what?
Every decision in a design system needs an owner. When nobody owns a decision, whoever speaks loudest makes it, and the system drifts. Governance names the roles and says what each role is allowed to decide.
Roles and decision rights
Core team
The group that owns the system as a whole. It checks that new work fits the rest of the system, keeps the shared parts working, and publishes releases. Its main job is the system itself, not one product. Some organisations call this group a council.
Contributors
Anyone who can suggest or build a change. This can be a product designer, a researcher, or an engineer. Contributors write the first draft of a proposal and answer review questions. They usually do not make the final call on shared parts.
Approvers
The people who give the final yes or no on a change. In a small system this may be the core team alone. In a larger one, a working group with people from design and engineering may review bigger items. Approvers should be named in advance, so nobody has to guess who signs off.
Decision rights set the limits for each role. A simple split works like this. Product teams decide the details of their own screens. The core team decides whether a new shared part is added. Approvers decide whether a change to a shared part is released.
Many checklists also list the adopters, meaning the teams that use the released parts in their products. Adopters do not vote on changes, but they are expected to move to new versions and to report problems they find.
How central should the control be?
An operating model describes how much of the work and control sits in one central place. Governance writers usually describe three common models.
Centralized
A dedicated team owns the system from start to finish. Ownership is very clear, but this team can become a bottleneck when many products ask for changes at once.
Federated
Product teams have real ownership of parts and clear routes for contributing. Shared rules are still set in one place, but more of the work happens inside product teams. This model only works when the written guides are strong, so teams do not drift apart.
Hybrid
A mix of both. A central group keeps the core rules and the shared foundations, while product teams can add local parts that fit inside those rules.
Tip
Pick the model that matches how many people contribute and how fast the products change. A new system often starts centralized, because one small group can keep the first parts consistent. As more teams join, a hybrid model is a common next step.
How does a change move through the system?
The contribution process is the set of steps a new or changed part must pass before it reaches teams. Clear steps stop good ideas from getting lost and stop weak ideas from slipping in unchecked.
From request to release
- 1
Request
The person with the need describes the problem. A good request names the gap, the users affected, and what the team already tried. Keep one single place to send requests, such as one form or one issue board.
- 2
Check for fit
The core team asks whether an existing part already covers the need, or whether an existing part could be extended. GOV.UK's contribution criteria say that a proposal must not copy something already in the system.
- 3
Propose
The contributor writes a short proposal with the context, the use cases, and mockups. Accessibility notes belong here from the start, not at the end.
- 4
Review
Reviewers test the work against the system's standards. Is it usable? Does it meet accessibility rules? Is the naming consistent with existing parts? Does it work at common screen sizes? GOV.UK asks reviewers to check that a part is usable, consistent, and versatile, and that it has been tested with real users.
- 5
Decide
The approver chooses one outcome: accept, reject, or refine. Refine sends specific feedback back to the contributor, who revises the work and returns it. Every outcome should come with a short reason.
- 6
Release
The approved part is added to the design library and its documentation, and it is published with a version number and a note about what changed.
Not every change needs the full process. Some teams sort changes into tiers. Small fixes can pass through with automatic checks, medium changes get a short review, and large changes such as a new visual style get a full review. This keeps small work moving without lowering the bar for big changes.
Tip
Write down the reason for every decision, including rejections. People accept a no more easily when they can see the reasoning, and the reasons save time when the next person asks the same question.
What about requests that do not fit the system?
Teams will always have needs the system does not cover yet. They may need a one-off screen, a test, or a deadline that cannot wait. Good governance does not ban these. It gives them a fast, recorded route, so they do not become permanent by accident.
Log the exception
The team records the custom part in an exception list, with the reason for it and a named owner.
Set a review date
Each exception gets a date for a fresh look. This stops a temporary fix from quietly becoming permanent.
Decide at review
At that date the part is promoted into the system, migrated to an existing part, or deprecated with an end date.
GOV.UK guidance for teams building services gives one more route. If a team needs a very large change, it can copy the component and give the copy a new name. This protects the service from future updates, but the copy will not receive the original's updates either. Small changes should use the options the existing component already offers.
Tip
A one-off part that a second team copies becomes hard to remove. Catch duplicates early, while only one team depends on them.
Worked example: a new date picker variant
This example is illustrative. It follows the steps described in the sources, applied to an imagined product team at a large company, such as the ones that run GOV.UK's design system. It is not a record of a real request. Imagine a payments team that needs a date picker that selects a range of dates, not a single date. Here is how the request would move through the process.
- 1
Submit the proposal
The team writes a short proposal. It describes the user problem, names the two screens where the range picker is needed, includes a mockup, and notes how the picker works with a keyboard and a screen reader. The proposal goes to the single place where requests are sent.
- 2
Check for an existing part
The core team first asks whether the existing date input can already cover the need through a setting or a variant. GOV.UK's own criteria give a close example: a versatile date input can ask for a year only, a month and year, or a full date. If an existing part can cover the need, the answer is to extend it, not to create a new one.
- 3
Review the design
The need is real and no existing part covers it, so reviewers test the range variant. They check that it reuses existing styles, that users can complete the task, and that it works with assistive technology and common browsers.
- 4
Approve
The approver accepts the variant and writes down the reason, such as that several services need range selection and that the existing input cannot do it without confusing users.
- 5
Publish with a version note
The variant is added to the library as a minor change, which means new options that keep existing uses working. The release note says what the variant does and when to use it.
- 6
Deprecate duplicates
The payments team had already built its own one-off range picker inside its product. Once the official variant is out, that copy is marked as deprecated, given a migration guide that shows how to switch, and given an end date.
Tip
Step 2 saves the most work. A variant that extends an existing part is cheaper to maintain than a new part that looks almost the same.
How do you communicate and maintain change?
A design system is never finished. Parts change, teams need time to catch up, and old parts must eventually retire. Governance covers this stage too, through version numbers, clear notes, a fair way to retire old parts, and support for teams that move to new versions.
Versioning
Versioning means numbering each release so people can judge how big a change is before they adopt it. Most teams use three numbers.
Patch
A small fix. It should not change how a part looks or behaves in a way that users or teams need to act on.
Minor
New options or parts added in a way that keeps existing uses working. Teams can usually upgrade without rework.
Major
A change that can break existing uses, such as renaming a part or changing a default value. Teams should review their work before they upgrade.
Release notes and migration notes
Every release needs a short, plain summary. For a rename or a pattern change, show a before-and-after example.
How do you deprecate old components?
Deprecation warns that a part should no longer be used, and that it will be removed later. A deprecation should follow a fixed path, so teams are never surprised by a part that disappears.
- 1
Announce
Mark the old part as deprecated in the documentation and in the design library.
- 2
Provide a migration guide
Show exactly how to switch to the replacement, with before-and-after examples.
- 3
Set a timeline
Choose an end date and a window for moving. Choose a window that fits how often you release, and state it clearly.
- 4
Keep it working
Until the window closes, the old part still works.
- 5
Remove
After the window, remove the part, usually in a major version. Before you do, check which products still use it, so you know who to contact.
GOV.UK Design System shows a different lifecycle. It releases new parts in a trial status, which tells users the part may still change. A trial part that gets no negative feedback moves to stable after six months, and parts that stop meeting user needs are deprecated.
How do teams adopt updates?
Releasing a change is not the same as teams using it. Teams need time, a clear reason to move, and help with the switch. Good governance also tracks which teams use which versions. A team that never upgrades can end up relying on an old part that nobody maintains.
Tip
When you announce an update, say what teams gain from it, not only what they must change. A reason to move gets far more action than a warning alone.
Check your understanding
Quick check
Two product teams have each built a slightly different toast notification, which is a small message that pops up to confirm an action. Both want it added to the design system. Using what this lesson covered, what should happen before either version is accepted, and who decides?
Quick check
A design system team wants to retire an old alert part that many products still use. Which plan follows good governance?
Quick check
The core team changes the default size of a button. Existing screens will look different wherever the default was used, but no part is renamed. Which version change fits best?
Key takeaways
Name the owners
Write down who is the core team, who contributes, who approves, and who decides what. A short one-page brief is enough to start.
Run one clear path
Every change should be requested in one place, checked for fit with existing parts, reviewed against shared criteria, decided with a reason, and released with a version number.
Retire with notice
Mark old parts as deprecated, give a migration guide and an end date, keep them working until then, and help teams move at their own pace.
Sources
- GOV.UK Design System: Contribution criteria
- GOV.UK Design System: Propose a component or pattern
- GOV.UK Design System: Component lifecycle statuses
- GOV.UK Design System: Extending and modifying components in production
- GOV.UK Design Notes: Opening up the GOV.UK Design System for contributions
- WireGov: Introducing the GOV.UK Design System
- Home Office Design System: Contribute to the design system
- Ramotion: Design System Guide, Chapter 8, Maintenance and Evolution
- Figr: Design System Versioning
- Figr: Design System Guide, Build, Manage, and Scale
- Magic Patterns: Design System Maintenance, How to Prevent Drift and Decay
- EightShapes: Versioning Design Systems, Communicating Change Clearly
- Design System Rules (versioning and contribution rules)
- Honcho: Design system governance best practices
- SeaLab: Design System Governance Models, Metrics, and ROI
- Société Générale Design: Taming Chaos, Design System Governance at Scale
- HikeOn Design System: Design Governance checklist
- UXPin: Design System Governance, A Guide to Prevent Drift
- UXPin: Design System Contribution Model
- Designsystemscollective: Versioning Your Design System Without Breaking Client Sites
- Medium: Design System Governance That Doesn't Kill Momentum
Last updated on 17 November 2026
Related lessons
- Design systemsDesign Language: The Look, Feel, and Voice Behind a Design System
- UI/UX basicsTarget Outcome: Decide the Change Before the Design
- Design systemsPerformance: How Design Choices Keep Design System Parts Fast
- Design systemsDesign Editor: Set Up One Shared Design System File Your Team Can Trust
Learn with me
Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.