Design system governance that makes the shared component the easy choice
If teams keep copying shared components, design system governance gives those teams a clear route for requests and exceptions, so the copies stop.
2017
Founded
90+
Projects
19
Countries with clients
What you get from design system governance
Named owners and a quick change path, so using the system is faster than working around it.
Who does the work
A senior designer leads the governance work with a design engineer who reads your code, and an account lead runs the schedule. We take the first few changes through the new path beside your owners, then step back.
What we need from you
Access to live screens, code and the library, time with each system owner, and an honest account of how changes reach the system today.
Where our part stops
Your owners run the system once the first changes are through. If nobody has agreed what belongs in the system, start with Design System Strategy; if the system itself needs examining first, start with a Design System Audit.
Selected design system governance work
None of our case studies is a governance set-up on its own. The nearest three show shared parts adopted, extended and rolled out.

Ryzeo: shared rules so the next report follows the first
We redesigned reporting in Ryzeo's marketing-automation product and documented reusable components with shared rules for filters, states, data treatments and navigation. The next report, and any screen after it, can follow the same logic.

Doodle: adding to a design system we didn't build
On Doodle's scheduling MVP we were the team adding to an existing design system. We used what was there and made new components only for the calendar and bookability work. A contributor needs a clear list of what exists and a quick answer on whether a new part belongs.

Benchmark Gensuite: one shared control at a time
We proved the scope selector, a shared control every application in the suite depends on, in coded prototypes, then checked it with Benchmark's engineers and against the habits customers rely on. The same approach can carry the rest of the suite, one control at a time.
The design system governance process, and where exceptions live
Every change gets a clear path that fits how your teams already plan their work.
| Step | What happens |
|---|---|
| Request | A product team brings a need, with the screen and the cases involved |
| Sort | System owners choose: keep it in the product, change an existing component, or add a new one |
| Build | Named people design, code, review and document the change |
| Release | Figma, code and documentation update together, with notes on what changed and how to move across |
| Confirm | The team that asked checks it works in their product |
Code from AI coding tools takes the same path as code a person writes. Our article follows how a product need becomes a shared design system release.
Exceptions are normal. Hidden ones are the problem, so each one goes on a register where every team can see it.
Illustration, not client work
Three entries from the exceptions register of a SaaS company with four product teams.
| Exception | Type | Owner | Review |
|---|---|---|---|
| A pricing table with a frozen first column, used only in Billing | Product-specific: it belongs to one workflow | Billing's design lead | At the next quarterly system review |
| A date-range picker built locally for Reports | Temporary: the shared picker will cover it | Reports' frontend lead | When the shared picker gains range selection |
| An inline status badge two teams built separately | A candidate for the system | The system owners | At the next release planning |
Once it is visible, an exception can be revisited on its date, moved into the system or retired.
Design system governance models, and the teams each one suits
| Model | How it works | Best for |
|---|---|---|
| Central team | One core group designs, builds and releases every shared component | One product, or a few teams with similar needs |
| Contribution model | Product teams propose and build components; a core group reviews and releases them | Several teams with their own designers and developers |
| Shared core, local layers | A core group owns foundations and common components; each product owns its own layer through an agreed path | Several products or brands on one system |
A shared core with local layers suits most organisations with several product teams.
What clients say
Three ways to work with us
Not sure which suits you?
Tell us about the product, and we'll suggest one.
Why founders and product teams choose Tcules
Fluent in SaaS
Roles, permissions and data-heavy screens need no explaining to us.
Idea to launch
Bring an idea or your own prototype. Designers lead it through to launch.
Craft people notice
Your product stands out from lookalike software and feels effortless to use.
Evidence before screens
We test your assumptions with real users before they become expensive mistakes.
Seen your problem before
Senior designers who've solved problems like yours lead your product and do the work.
Start small
An optional fixed-price pilot lets you try us first, and ongoing work has no minimum term.

Tell us where your ‘just this once’ components live
Tell us what teams do when the system lacks a piece, and how changes reach it today.
Design system governance FAQs
How do we stop teams making local copies?
Make the shared component the easier option. Tcules fills the missing cases, makes contributing quick, and gives real exceptions an approved path, because teams follow whichever path costs them least.
How do we get teams to actually use our design system?
Fix the reason they leave it first, which is usually a missing case, a slow contribution path or drift between Figma and code. Then track how many screens use shared components and how many local copies remain.
What is a design system contribution model?
It is the agreed way a product team proposes, builds and releases a change to the shared system. A good one says who reviews, how long an answer takes and what the team does while it waits.
Who should own the design system?
Design system ownership usually sits with a small core group, with named people in design and engineering, who look after the foundations and shared components. Product teams own their exceptions, and how central the core group should be depends on how many teams use the system.
Can governance be fixed without rebuilding the system?
In most cases, yes. Tcules first separates problems with the components themselves from problems with how changes get made. Many systems need a better contribution path and nothing more.
Should AI-generated code follow the same rules?
Yes. Code from AI tools goes through the same request, review and release path as code a person writes. Give the tools your colours, components and usage rules, then review what they produce.