Book a call

WritingGovernancePart 4 of 4 in The operating model

Design system contribution model: how to take requests without becoming a bottleneck

Ten teams, forty requests, one small system team. Without a clear way in, the loudest team wins and the quiet ones build their own. One front door, a scoring formula, contribution levels and a review flow that keeps work moving.

On this pageWhy requests become a bottleneck
  1. Why requests become a bottleneck
  2. One front door: the request form
  3. Shared need or product-specific?
  4. How to score and prioritise requests
  5. Urgent requests and exceptions
  6. Four levels of contribution
  7. The request lifecycle
  8. Saying no, well
  9. The short version
  10. Frequently asked questions
  11. Further reading

The short answer

A design system contribution model is the agreed way product teams ask for changes and add their own work to the system. A good one has one front door (a short request form that creates an item in a public tracker), a weekly triage that decides whether each request is a shared need or a product-specific one, an open scoring formula for priorities, four contribution levels from reporting a bug to co-building a new component, and a visible lifecycle from request to adoption.

  • Ask for the problem, not the solution.
  • Priority = (Reach + Impact + Reuse + Business value) ÷ Effort, each scored 1–3, published next to every request.
  • The system should never be the reason a team misses a deadline: offer a sanctioned local build instead.

Why requests become a bottleneck

In the early days requests arrive informally: a message here, a hallway chat there. That works until about the third product team. Then requests get lost, the loudest team gets served first, and quiet teams decide the system isn't for them.

An illustration: whoever shouts loudest

The situation

Requests reach the system team through Slack, direct messages, meetings and a spreadsheet. A senior product manager escalates their team's request to a director.

What goes wrong

The escalated request jumps the queue. Two quieter teams who asked months earlier hear nothing. One builds its own components; the other says the system is "political".

What a framework changes

One front door, a public queue, a published scoring method and a weekly triage. Priorities can still change, but openly, with reasons everyone can see.

A request framework isn't bureaucracy. It's fairness made visible. It protects the system team from being pulled in ten directions, and it protects product teams from being forgotten.

One front door: the request form

All requests go through one place: a form on the documentation site that creates an item in a public tracker (GitHub issues, Jira or similar). Questions can still be asked in chat, but anything that needs work becomes a request. A good form takes two minutes and gives the system team everything it needs.

  1. What kind of request?

    Bug · Enhancement to an existing component · New component · New pattern · Token change · Documentation · Other

  2. What problem are you trying to solve?

    Describe the user need, not the solution. "Customers can't tell which invoices are overdue", not "add a red badge".

  3. Where does it appear?

    Product, screen, and a screenshot or Figma link.

  4. What have you tried?

    Existing components you considered, and why they didn't fit.

  5. Who else might need this?

    Other teams or products you know of.

  6. When do you need it, and why?

    The deadline and what depends on it. "Launch on 12 March" helps; "ASAP" doesn't.

  7. Could your team help build it?

    Yes / Maybe / No. Contributions get faster turnaround.

A seven-question request form. Question 2 matters most: the best answer to a request is often an existing component, a pattern, or something more general that helps other teams too.

Shared need or product-specific?

The most important judgement in triage: does this belong in the system, or in the product? Get it wrong one way and the system bloats with one-offs; the other way and teams duplicate work. Five questions settle most cases:

QuestionPoints to the system if…Points to the product if…
How many teams need it?Two or more now, or clearly soon (the rule of two)Only one team
Is the need general?A common problem: show status, pick a date rangeTied to one domain: a loan amortisation chart
Does it duplicate something?Nothing existing solves itAn existing component does, with small changes or better guidance
Will it last?A long-lived needA campaign, experiment or short-lived feature
Is it consistent with the system?Fits the principles and foundationsRequires breaking them

These echo the GOV.UK Design System's public contribution criteria, where proposals must show they're useful and unique before they're accepted. When the answer is "product-specific", the team builds it locally from system parts, and the request stays open as a watch item. If a second team asks, it becomes a candidate for the system.

How to score and prioritise requests

Every request accepted for the system gets a category and a score. The score doesn't decide automatically, but it makes trade-offs visible and discussions much calmer.

FactorQuestion123
ReachHow many teams or screens benefit?1 team2–4 teams5+ teams
ImpactHow much does it help each team or user?Nice to haveSaves real timeUnblocks or fixes a serious problem
ReuseWill it be reused in future work?RarelySometimesConstantly
Business valueDoes it support a priority, revenue, compliance or accessibility?IndirectSupports a priorityRequired for one
Effort (divides)How complex is it?SimpleModerateComplex
RequestReachImpactReuseValueEffortScore
Dialog focus bug (accessibility)3333112.0
Filter pattern for lists323225.0
Month-range date picker122223.5
Spreadsheet-style editable grid131232.3
Priority = (Reach + Impact + Reuse + Business value) ÷ Effort, each scored 1–3. An accessibility bug used everywhere scores 12; a complex grid for one team scores 2.3.

Publish the score next to each request in the public queue. When two teams compete, the scores start the conversation, but people finish it: agree a quarterly roadmap with product leads so most priorities are settled once, together, and when something genuinely moves mid-quarter, say what moves down to make room.

In practice

At CARS24 the design system team used a 70-point scorecard any team could apply to its own request, one front door and three ownership tiers. Read how the team stopped being the bottleneck. The Lab has a free request backlog tool that ranks requests with that scorecard and exports CSV, Markdown or JSON.

Urgent requests and exceptions

Define "urgent" clearly and give it a fast lane, or everything will be called urgent.

Qualifies as urgentFast-lane response
A system bug blocking a launch or a key user taskFixed within days as a patch release
A legal, regulatory or accessibility deadlinePrioritised above roadmap work, with leadership informed
A launch date with no time for the normal processBuild locally now from system parts; the system version follows; the local one is replaced later

Exceptions, where a team needs to break a system rule, should be allowed but explicit: a short written request, a named approver, an expiry date and an entry in an exception log. Review the log quarterly. Recurring exceptions are a sign the system needs to change.

Our rule

The system should never be the reason a team misses a deadline. If it can't deliver in time, the answer is a sanctioned local build, not a delay. That one promise does more for trust than any process.

Four levels of contribution

When a team offers to build something themselves, the request becomes a contribution. Different kinds need different support, but the same standard:

LevelContributor providesSystem team providesReview
1 · ReportA clear description with a screenshotTriage within a week—
2 · FixThe fix, a test, a changelog lineReview within 2–3 daysOne reviewer
3 · ExtendA short proposal; then design, code, tests and docsProposal feedback; pairing if wantedDesigner and engineer
4 · NewA written proposal with evidence of shared need; co-buildingKick-off workshop, co-design, final reviewDesign, code and accessibility review
Contribution levels. All contributions meet the same definition of done as system-built work. Contributors shouldn't get a lower bar; they should get more help reaching it.

Nathan Curtis has written in depth about contribution and about the criteria for "does this go in the system?". Both are worth reading before you write your own guidelines.

The request lifecycle

Every request moves through the same stages, visible to everyone in the tracker, so the requester always knows where it is and what happens next.

SubmittedForm completed; auto-acknowledged
→
TriagedShared vs local; scored; answered within a week
→
AcceptedOn the roadmap with a timeframe, or invited as a contribution
→
In progressRequester reviews design before build
→
ReleasedShipped, announced, requester thanked
→
AdoptedRequesting team using it; local versions retired
Requests can also leave at triage as "use existing", "build locally (watching)" or "not planned", always with a written reason. A request isn't finished when it's released; it's finished when the team that asked is using it.
StageOwnerService target
Submitted → triagedSystem lead (weekly triage)First response within a week
AcceptedSystem leadTimeframe stated; roadmap updated
In progressComponent owner (designer + engineer)Requester reviews design before build
ReleasedEngineer on release rotaAnnounced with the release
AdoptedRequesting team's championWithin one or two release cycles

Saying no, well

Most requests that don't go into the system still deserve a good answer. "No" should almost always come with something useful:

"Use this instead"

An existing component or pattern solves it, with a link and a short example.

"Build it locally, we're watching"

Product-specific for now. Build from system parts; if a second team asks, it comes in.

"Not planned, because…"

It conflicts with a principle or a standard. Say which, and what would change the answer.

The short version

  • One front door and a public queue; ask for the problem, not the solution.
  • Test every request for shared versus product-specific need; send one-offs to local builds and watch them.
  • Score openly: (Reach + Impact + Reuse + Value) ÷ Effort. Define urgent; make exceptions explicit.
  • Four contribution levels, one standard, more help for contributors.
  • Track every request from submission to adoption, with an owner and a target at each stage.

Frequently asked questions

Who can contribute to a design system?

Anyone who uses it. Reports and fixes should be open to everyone; extensions and new components need a proposal and the system team's support.

How do you prioritise design system requests?

Score each one by reach, impact, reuse and business value, divided by effort, and publish the scores. Then agree a quarterly roadmap with product leads so most priorities are settled together.

What if a team needs a component now?

Let them build it locally from system parts, as a sanctioned exception. The system version follows and replaces it later.

Should contributions go through pull requests?

Code contributions, yes, with the same review and tests as system-built work. But a pull request isn't a proposal: for extensions and new components, agree the design first.

How quickly should requests get a response?

A first response within a week, from a weekly triage. Fixes contributed by teams should be reviewed within two or three days.

Further reading