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
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.
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".
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.
What kind of request?
Bug · Enhancement to an existing component · New component · New pattern · Token change · Documentation · Other
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".
Where does it appear?
Product, screen, and a screenshot or Figma link.
What have you tried?
Existing components you considered, and why they didn't fit.
Who else might need this?
Other teams or products you know of.
When do you need it, and why?
The deadline and what depends on it. "Launch on 12 March" helps; "ASAP" doesn't.
Could your team help build it?
Yes / Maybe / No. Contributions get faster turnaround.
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:
| Question | Points 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 range | Tied to one domain: a loan amortisation chart |
| Does it duplicate something? | Nothing existing solves it | An existing component does, with small changes or better guidance |
| Will it last? | A long-lived need | A campaign, experiment or short-lived feature |
| Is it consistent with the system? | Fits the principles and foundations | Requires 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.
| Factor | Question | 1 | 2 | 3 |
|---|---|---|---|---|
| Reach | How many teams or screens benefit? | 1 team | 2–4 teams | 5+ teams |
| Impact | How much does it help each team or user? | Nice to have | Saves real time | Unblocks or fixes a serious problem |
| Reuse | Will it be reused in future work? | Rarely | Sometimes | Constantly |
| Business value | Does it support a priority, revenue, compliance or accessibility? | Indirect | Supports a priority | Required for one |
| Effort (divides) | How complex is it? | Simple | Moderate | Complex |
| Request | Reach | Impact | Reuse | Value | Effort | Score |
|---|---|---|---|---|---|---|
| Dialog focus bug (accessibility) | 3 | 3 | 3 | 3 | 1 | 12.0 |
| Filter pattern for lists | 3 | 2 | 3 | 2 | 2 | 5.0 |
| Month-range date picker | 1 | 2 | 2 | 2 | 2 | 3.5 |
| Spreadsheet-style editable grid | 1 | 3 | 1 | 2 | 3 | 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.
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 urgent | Fast-lane response |
|---|---|
| A system bug blocking a launch or a key user task | Fixed within days as a patch release |
| A legal, regulatory or accessibility deadline | Prioritised above roadmap work, with leadership informed |
| A launch date with no time for the normal process | Build 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.
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:
| Level | Contributor provides | System team provides | Review |
|---|---|---|---|
| 1 · Report | A clear description with a screenshot | Triage within a week | — |
| 2 · Fix | The fix, a test, a changelog line | Review within 2–3 days | One reviewer |
| 3 · Extend | A short proposal; then design, code, tests and docs | Proposal feedback; pairing if wanted | Designer and engineer |
| 4 · New | A written proposal with evidence of shared need; co-building | Kick-off workshop, co-design, final review | Design, code and accessibility review |
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.
| Stage | Owner | Service target |
|---|---|---|
| Submitted → triaged | System lead (weekly triage) | First response within a week |
| Accepted | System lead | Timeframe stated; roadmap updated |
| In progress | Component owner (designer + engineer) | Requester reviews design before build |
| Released | Engineer on release rota | Announced with the release |
| Adopted | Requesting team's champion | Within 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
- Contributions to Design SystemsNathan Curtis, EightShapes.
- I made this. Does it go in the system?Nathan Curtis. Contribution criteria.
- GOV.UK contribution criteriaGovernment Digital Service.
- A Design System Governance ProcessBrad Frost.
