Skip to content
NewTemplates & toolkits are on the way — join the waitlist
Hecham Gazhi

Design Systems · Lesson 13 / 13

Governance & versioning

How a design system is run over time: team models, contribution process, decision-making, semantic versioning, deprecation, communication, measuring adoption and health, and getting buy-in.

5 min read · 5 quiz questions

Why governance matters

A design system is never finished. Products change, new needs appear, bugs are found, brands evolve. Governance is how the system handles that change: who decides, how people contribute, how updates are released, and how the system stays healthy instead of becoming outdated or ignored.

Without governance, systems tend to fail in one of two ways: they freeze (nobody can change anything, so teams build around it) or they sprawl (everyone adds whatever they want, so it's no longer consistent).

Team models

Nathan Curtis described three common ways to staff a design system:

ModelHow it worksProsCons
SolitaryOne team builds the system for itself; others may copy itFast to startDoesn't scale; others aren't served
CentralisedA dedicated team builds and maintains the system for everyoneConsistent, high quality, clear ownershipCan become a bottleneck; may lose touch with product needs
FederatedDesigners and developers from product teams contribute part-timeClose to real needs, shared ownershipSlower decisions; needs strong coordination

Many organisations use a hybrid: a small core team owns foundations, quality and releases, while product teams contribute components and patterns through a defined process.

Contribution process

A clear path from "I need something" to "it's in the system" prevents both bottlenecks and sprawl:

  • A useful rule: something becomes a system component when it's needed in several products or places — not because one team needs it once.
  • Not every contribution must be big. Small fixes, doc improvements and new examples are valuable contributions too.
  1. 1Check — does something in the system already solve this? Can an existing component be used or extended?
  2. 2Propose — open a request describing the problem, the use cases and which products need it.
  3. 3Review — the system team decides: add to the system, extend an existing component, or keep it as a local one-off (a "snowflake").
  4. 4Design — design all variants, states, responsive behaviour and accessibility, with review from the system team.
  5. 5Build — implement in code with tests, using tokens.
  6. 6Document — write the docs page.
  7. 7Release — publish in Figma and code together, announce it, and add it to the changelog.

Semantic versioning

Version numbers communicate the impact of a change. Semantic versioning uses MAJOR.MINOR.PATCH:

ChangeVersionExamples
MAJOR (2.0.0)Breaking changes — product code or designs must be updatedA prop is renamed or removed; a token is deleted; default behaviour changes
MINOR (1.4.0)New, backward-compatible featuresA new component; a new variant; a new optional prop
PATCH (1.3.2)Backward-compatible bug fixesFixing a focus ring colour; correcting padding to match the spec
Exampletext
## 3.0.0 — 2026-11-10
### Breaking
- Button: `type` prop renamed to `variant`. Run the codemod: npx @acme/codemods button-variant
- Removed deprecated `Badge` color "purple".
### Added
- New `Combobox` component.
### Fixed
- Text field error message now announced by screen readers.

Deprecation: change without chaos

  1. 1Announce the deprecation with the reason and the replacement.
  2. 2Mark it in Figma (e.g. a ⚠️ prefix) and in code (console warnings, @deprecated in TypeScript).
  3. 3Provide a migration guide and, where possible, a codemod.
  4. 4Give time — typically at least one minor release cycle or a set period.
  5. 5Remove it in the next major version.

Common mistake: Deleting or changing components without warning. Teams lose trust quickly when an update breaks their product — and a system people don't trust is a system people stop updating.

Communication

  • A changelog for every release, written for humans.
  • A public roadmap showing what's planned, in progress and recently shipped.
  • Release notes shared in the channels teams actually read.
  • Office hours where anyone can bring questions or designs for review.
  • A support channel with a predictable response time.
  • Showcases of products using the system well.

Measuring adoption and health

MetricHow to measure
Adoption% of products, screens or code that use system components (code scanning, Figma library analytics)
CoverageHow much of a typical product's UI can be built from the system
Detach rateHow often Figma instances are detached — a sign of unmet needs
Version lagHow far behind the latest version products are
EfficiencyTime to design or build common screens before and after
QualityAccessibility issues and UI bugs in products using the system
SatisfactionRegular surveys of designers and developers

Getting and keeping buy-in

  • Speak in outcomes leadership cares about: faster delivery, fewer bugs, accessibility compliance, brand consistency.
  • Show the interface inventory — 40 different buttons is a powerful argument.
  • Start with a pilot on one product and measure the improvement.
  • Treat product teams as customers: listen, prioritise their needs, make adoption easy.
  • Celebrate contributions and credit contributors publicly.

Do

  • Define who decides and how people contribute.
  • Version every release and write clear changelogs.
  • Deprecate before deleting, with migration help.
  • Measure adoption and listen to detached components.

Don't

  • Let the system freeze or sprawl.
  • Add one-off components to the system.
  • Ship breaking changes in a patch release.
  • Assume teams will adopt the system without support.

Key takeaways

  • Governance keeps a design system from freezing or sprawling.
  • Team models: solitary, centralised, federated — or a hybrid of core team plus contributors.
  • A clear contribution process decides what joins the system: shared needs, not one-offs.
  • Semantic versioning (MAJOR.MINOR.PATCH) and changelogs communicate the impact of changes; deprecate before you delete.
  • Measure adoption, detach rate, version lag and satisfaction, and treat product teams as customers.

Exercise

Write a governance one-pager

  1. Choose a team model for a fictional company with 4 product teams.
  2. Write the contribution process as 6–7 steps.
  3. Classify these changes as major, minor or patch: new Tooltip, renamed prop, fixed padding, removed colour token.
  4. Write a changelog entry for a release containing those changes.
  5. Pick three metrics to measure the system's health and how you'd collect them.

Test yourself

Governance & versioning quiz

5 questions. Score 70% or more to complete the lesson.

  1. 1.Renaming a component prop is which kind of release?
  2. 2.Adding a new optional variant is which kind of release?
  3. 3.In a federated model…
  4. 4.What should happen before deleting a component?
  5. 5.When should a component become part of the system?