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.

The design system governance process, and where exceptions live

Every change gets a clear path that fits how your teams already plan their work.

StepWhat 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.

ExceptionTypeOwnerReview
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

ModelHow it worksBest 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

  • “Tcules reused our existing components wherever they could, and designed new ones only for the calendar and scheduling work our system didn't cover yet. Everything they added was organised to fit the system we already had.”

    Stephanie LeueDoodle
  • “Our customers wanted reports that answered their own questions. Tcules researched how they used our reporting, redesigned it and gave us shared rules for filters, states and data, so new work can follow the same logic.”

    Russell MilerCOO, Ryzeo
  • “For three years Tcules has designed every one of our products. They work like part of our product team, improving them continuously and helping us shape AI features our customers can check and trust.”

    Clément ContamineCPO, Primelis

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.

Design System Governance and Adoption Services | Tcules