# 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.

From "Design systems", a free course by Venkat R. Murty: https://designervenkat.online/learn/design-systems/governance

## 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.

- **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?

A. The version that has been live longer goes in automatically, because real users have already seen it.
B. Both versions are logged as proposals. The core team checks whether an existing message part already covers the need, both are reviewed against the same criteria, and an approver decides which version, or a merged version, is released.
C. Each team publishes its own toast under its team name, so product teams can choose the one they prefer.
D. The two team leads agree between themselves, and the core team records the decision afterwards.

**Answer:** B. Governance means a proposal is logged, checked against what already exists, reviewed against shared criteria, and decided by a named approver. Two near-copies should be merged into one part rather than kept side by side.

**Quick check:** A design system team wants to retire an old alert part that many products still use. Which plan follows good governance?

A. Delete the old part in the next release and ask teams to fix anything that breaks.
B. Mark the old part as deprecated, publish a migration guide, set an end date, and keep the part working until that date.
C. Keep the old part forever, because removing it might upset someone.
D. Ask each team to choose its own switch date, and remove the part once most teams say they have moved.

**Answer:** B. Deprecation is a managed path: announce it, explain the switch, set a window, keep the old part working during that window, and only then remove it. Deleting it at once skips the warning and the migration support.

**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?

A. Patch, because the change is small.
B. Minor, because nothing was removed or renamed.
C. Major, because existing screens may change and teams should review their work before they upgrade.
D. No new number, because a design tweak is not a release.

**Answer:** C. A change to a default value that shifts how existing screens look can break what teams expect, so it counts as a major change even though nothing was renamed or removed.

## 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](https://design-system.service.gov.uk/community/contribution-criteria/)
- [GOV.UK Design System: Propose a component or pattern](https://design-system.service.gov.uk/community/propose-a-component-or-pattern/)
- [GOV.UK Design System: Component lifecycle statuses](https://design-system.service.gov.uk/community/component-lifecycle-statuses/)
- [GOV.UK Design System: Extending and modifying components in production](https://design-system.service.gov.uk/get-started/extending-and-modifying-components/)
- [GOV.UK Design Notes: Opening up the GOV.UK Design System for contributions](https://designnotes.blog.gov.uk/2018/09/26/opening-up-the-gov-uk-design-system-for-contributions/)
- [WireGov: Introducing the GOV.UK Design System](https://www.wired-gov.net/wg/news.nsf/articles/Introducing+the+GOV.UK+Design+System+25062018111000)
- [Home Office Design System: Contribute to the design system](https://design.homeoffice.gov.uk/design-system/contribute)
- [Ramotion: Design System Guide, Chapter 8, Maintenance and Evolution](https://www.ramotion.com/blog/design-system-guide-chapter-8-maintenance-and-evolution/)
- [Figr: Design System Versioning](https://figr.design/blog/design-system-versioning)
- [Figr: Design System Guide, Build, Manage, and Scale](https://figr.design/blog/design-system-guide)
- [Magic Patterns: Design System Maintenance, How to Prevent Drift and Decay](https://www.magicpatterns.com/blog/design-system-maintenance)
- [EightShapes: Versioning Design Systems, Communicating Change Clearly](https://medium.com/eightshapes-llc/versioning-design-systems-48cceb5ace4d)
- [Design System Rules (versioning and contribution rules)](https://markdowners.com/m/markdowners/design-system-rules)
- [Honcho: Design system governance best practices](https://honcho.agency/design-systems/design-system-governance-best-practices)
- [SeaLab: Design System Governance Models, Metrics, and ROI](https://sealab.design/blog/design-system-governance/)
- [Société Générale Design: Taming Chaos, Design System Governance at Scale](https://medium.com/societe-generale-design/taming-design-system-chaos-66bcadbf43e1)
- [HikeOn Design System: Design Governance checklist](https://ds-checklist-one.vercel.app/)
- [UXPin: Design System Governance, A Guide to Prevent Drift](https://www.uxpin.com/studio/blog/design-system-governance/)
- [UXPin: Design System Contribution Model](https://www.uxpin.com/studio/blog/design-system-contribution-model/)
- [Designsystemscollective: Versioning Your Design System Without Breaking Client Sites](https://www.designsystemscollective.com/versioning-your-design-system-without-breaking-client-sites-93b7c652f960?gi=d4558c2d9a48)
- [Medium: Design System Governance That Doesn't Kill Momentum](https://robertcelt95.medium.com/design-system-governance-that-doesnt-kill-momentum-1ff6c3af6b5f)
