Marcus Andrey Study
Ler em português Library

Framework · Design systems · 3 min read

Contribution process

A lightweight path from a domain need to a released pattern (check existing, propose, council review, build, document, announce) that lets many teams grow the design system without you reviewing everything.

  1. 1Need

    A domain designer names the user problem and where it appears.

    "What is the user trying to do?"
  2. 2Check existing

    Ask in office hours or the channel whether something already solves it.

    "Does a pattern already fit?"
  3. 3Proposal

    Problem, draft, and use cases from two or more domains if possible.

    "Who else needs this?"
  1. 4Council review

    Accept as core, accept as domain-specific, or reject with a reason.

    "Which tier, and why?"
  2. 5Build, document

    Build in design and code, write usage guidance and release notes.

    "How should teams use it?"
  3. 6Announce

    Show it at show and tell, credit the contributor, log cycle time.

    "How long did it take?"
The contribution process moves a domain need to a released pattern, and every proposal gets an answer.

Use it when

  • A domain designer builds a new pattern locally and asks how to get it into the design system.
  • Several teams have each built their own version of the same thing, such as a filter panel or a date picker.
  • You notice you are the bottleneck: every component question waits for your personal review.

How to use it

  1. Capture the need in the domain. The designer who has the need writes down the user problem and the screen where it appears, before designing a solution. Output: a one-line need with a link to the screen.
  2. Check what already exists. Ask in office hours or the design-system Slack or Teams channel whether an existing component or pattern solves it. Many needs end here, with a pointer or a small variant. Output: "use X" or "nothing fits, because…".
  3. Write a short proposal. Describe the problem, the use cases (from two or more domains if possible) and a draft. Require use cases from at least two domains for anything that wants to become core. Output: a one-page proposal in a shared template.
  4. Review it in the council. At the regular council review (bi-weekly), decide one of three outcomes: accept as core, accept as domain-specific, or reject with a reason. Output: a recorded decision and reason, sent back to the proposer.
  5. Build, document and release. Build the component or pattern in design and code, write the usage guidance and add it to the release notes. Output: a released pattern with docs and a release-notes entry.
  6. Announce it and track cycle time. Show it in the next show and tell, credit the contributor, and log how long it took from proposal to release. Output: an announcement and one cycle-time number.

Worked example

An internal operations platform with 6 product teams. A designer in the warehouse domain needs a way to edit many rows of a table at once.

Step What happened
Need "Shift leads must change the status of 40 orders at once; today they edit each row."
Check existing Office hours: the table has row selection but no bulk actions. Nothing fits.
Proposal Problem, a draft bulk-action bar, and use cases from the warehouse and billing domains.
Council review Accepted as core, because both domains use the shared table. A confirmation step for destructive actions is required.
Build and document The design-system designer and the frontend lead build it; usage guidance and release notes are published.
Announce Shown at show and tell, contributor credited. Cycle time logged: five weeks from proposal to release.

Watch out for

  • Silent rejections. A proposal with no answer feels like a no without a reason. Answer every proposal, and say why.
  • You review everything. If every contribution needs your personal approval, you are back to solitary governance with extra steps. Let the council decide.
  • Core from one domain. A pattern that only one team needs belongs in the domain-specific tier. Ask for use cases from two or more domains before it becomes core.
  • No cycle-time data. If you don't measure how long contributions take, you can't tell whether the process is lightweight or just slow.

Template

Copy this into your design-system wiki as the proposal form.

Contribution proposal

Proposer:                Domain:              Date:
Need (user problem, one line):
Where it appears (link):
Checked existing? Yes / No   Closest existing pattern:

Use cases
  Domain 1:
  Domain 2:
  Domain 3 (if any):

Draft (link):
Requested tier: Core / Recommended / Domain-specific / Experimental

Council decision: Accept as core / Accept as domain-specific / Reject
Reason:
Decided on:        Released on:        Cycle time (days):

"See on Amazon" links are affiliate links. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.

Saved only on this device.

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