Marcus Andrey Study
Ler em português Library

Design Systems · Step 7 · 6 min read

Contribution models

Who can change a design system, and how. The three team models behind most systems, a contribution path with a bar people know in advance, and how to say no without losing the person who asked.

A model rail yard on a plinth: one main line, and three sidings that join it, each with a buffer stop and a wagon waiting. Point at a siding: its wagon rolls down through the junction and out onto the main line, while the wagons on the other sidings edge up. That's this step: many teams build, and the system needs one clear way for their work to join the core, one at a time. This step has three lessons: contribution models, deprecation and breaking changes, and multi-brand and multi-product systems.Illustration: Marcus Andrey, drawn with Hairline (MIT, Lucas Marques).

A design system that only its own team can change will always be behind the products it serves. The people who find the gaps first are the product designers and engineers, on a deadline, with a real screen in front of them. Contribution is how their fixes reach everyone else, instead of staying in one product as a quiet fork. Governance is the set of rules that makes that safe.

What you'll be able to do after reading:

  • Name the three team models and say which one you have
  • Draw a contribution path from request to release
  • Set a bar for contributions that people know before they start
  • Say no to a contribution and keep the contributor

1. Who decides: three team models

Solitary

Who decides
The team that built it, for its own product
Works when
There is one product, or the others are happy to follow
Breaks when
Other teams need something the owners don't, and start building their own

Centralised

Who decides
A system team that doesn't ship product screens
Works when
There's budget for the team, and products need a common base fast
Breaks when
The team loses touch with real product problems and becomes a queue

Federated

Who decides
A group drawn from the product teams, with time set aside for it
Works when
Senior people can give real hours, and someone still coordinates
Breaks when
"Everyone owns it" turns into nobody having the time
Three ways to organise the people behind a system, after Nathan Curtis. The model decides who can say yes to a contribution, so pick it before you write the process. Most teams end up with a small central core plus federated contributors.Diagram: Marcus Andrey, CC BY 4.0. Model names from Nathan Curtis, "Team Models for Scaling a Design System" (EightShapes, 2015).

In 2015 Nathan Curtis described three ways organisations staff a system (Team Models for Scaling a Design System, EightShapes):

  • Solitary. One product team builds a library for itself and lets others use it. It's how Harbour started: two people on Tidewater's booking app. The problem shows up when the staff console needs something the booking team doesn't, and nobody has a reason to build it.
  • Centralised. A dedicated team serves every product. It can see across the whole portfolio, but it doesn't ship product screens, so it can lose touch with real constraints and turn into a queue.
  • Federated. Designers from several product teams make system decisions together. It keeps the system close to real work, but only if those people get actual time for it.

You don't have to choose one forever. Most systems that last end up with a small central core that owns quality and releases, and contributors in the product teams. Curtis himself wrote that organisations were moving from solitary and centralised teams "towards a more federated approach".

The model matters for this lesson because it answers one question: who can say yes? Write that down before you write any process.


2. Kinds of contribution

Not every contribution is a new component. Carbon, IBM's system, separates new components from improvements to existing ones: enhancements, design kit updates, documentation, bug fixes (Carbon, Contributing). Size the process to the change:

Contribution Example in Harbour Process
Fix The focus ring on Button is invisible in dark mode A pull request or a Figma branch, reviewed by one person
Docs Add "When not to use" to Tag Edit the doc page, one review
Enhancement Notice needs an action slot Short proposal, then the normal review
New component or pattern A quantity stepper for passengers and cars The full path below

If fixing a typo takes the same five steps as a new component, people stop fixing typos.


3. A path with a known bar

  1. 1Propose

    The need, the evidence and where it shows up. No design yet.

    Any designer or engineer
  2. 2Triage

    Useful to more than one team? Not already in Harbour? Most requests stop or merge here.

    System team, within a week
  3. 3Build

    Design and code together, with tokens, states and accessibility from the start.

    Proposer, paired with the system team
  4. 4Review

    Tested with users? Reuses what exists? Works in more than one product?

    System team plus one product reviewer
  5. 5Release

    Library, package, doc page, changelog line, and a thank-you with the contributor's name.

    System team

Declined or parked requests go back to the proposer with the reason, and stay visible in the backlog.

How a contribution gets into Harbour, in five steps. Step 2 asks GOV.UK's two proposal questions (useful, unique) and step 4 its three publishing questions (usable, consistent, versatile), so the bar is known before anyone starts.Diagram: Marcus Andrey, CC BY 4.0. Criteria from the GOV.UK Design System contribution criteria.

The GOV.UK Design System publishes its contribution criteria, split in two stages. To be accepted for development, a proposal must be useful (evidence that many teams or services need it) and unique (it doesn't replicate something already in the system). To be published, it must be usable (tested in research with a representative sample of users, including people with disabilities), consistent (it reuses existing styles and components) and versatile (it works in a range of services) (GOV.UK Design System, Contribution criteria).

Two details in their process are worth copying:

  • Propose before you design. GOV.UK asks people to present the idea and the evidence of user need and to "avoid spending time working on a specific design or writing code" at that stage (Propose a component or pattern). It protects the contributor: if the answer is "use Notice", nobody has lost a week.
  • One public backlog. Ideas go into a shared list where people can add evidence to a proposal that already exists, instead of opening a new one.

4. Saying no, well

Most requests should not become new components. That's the system working, not failing. Brad Frost suggests waiting until a second team needs a pattern before adding it, so the library doesn't become a "Wild West" (Atomic Design, chapter 5).

A good no has three parts:

  1. The reason, tied to the criteria: "Not unique: Notice with tone="warning" covers this."
  2. A way forward: use this, or build it locally and we'll look again when a second team asks.
  3. A trace: the request stays in the backlog, so the next person who needs it adds evidence instead of starting over.

Sparkbox's 2022 survey of design system teams found that only 33% of maintainers were satisfied with how they accept contributions, and that those who called their system successful were more likely to have a contribution process in place (Sparkbox Design Systems Survey 2022). It's a self-selected sample of 219 people, so read it as a signal, not a law. The signal is clear enough: the process is hard, and it's worth having.


5. Credit and pairing

Contributions cost product teams time they are not measured on. Pay it back:

  • Pair. A system designer or engineer works with the contributor, so the work meets the bar without endless review rounds.
  • Name people. Put the contributor's name in the changelog and on the doc page.
  • Reciprocate. Curtis's federated model ends with a rule that's easy to forget: contribution should earn teams some autonomy in return.

6. Common mistakes

  • No written answer to "who can say yes?", so every request ends in a meeting.
  • One heavy process for everything, from typos to new patterns.
  • Asking for finished designs in the proposal, then rejecting them.
  • Saying no without a reason or an alternative, and getting a fork instead.
  • A backlog nobody outside the system team can see.

7. Vocabulary

Term Meaning
Governance The rules for who changes the system, how, and how changes are announced
Contribution A change to the system made by someone outside the core team
Solitary, centralised, federated Three team models: one product owns it, a dedicated team owns it, product teams own it together
Triage The first check of a request: is it useful and not already there?
Fork A local copy of a component that drifts away from the system

8. Try it (no tools needed)

  1. Think of the last time someone on your team built a component the system didn't have.
  2. Walk it through the five steps in the figure. Where would it have stopped?
  3. Write the one-line no, or the one-line yes, that it should have received.

Reflection questions: Who can say yes to a change in your system today, really? What does a product designer lose by contributing, and what could they gain?


9. If you already practise

  • Publish your criteria and your backlog where product teams can see them.
  • Track how long requests take from proposal to decision. If it's months, people will stop asking.
  • Offer a "fast lane" for fixes and docs, reviewed by one person within days.

Checklist

Learn more

Books, courses and videos to go deeper

Book links go to Amazon. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.

Run a contribution review · Deprecation and breaking changes · Bringing teams onto the system · Motion in design system governance · Funding and staffing a design system team · Contribution process · Design system governance models

Saved only on this device.

↑ ↓ to move · Enter to open · Esc to close