Book a call

WritingFoundations & tokensPart 5 of 6 in Tokens in practice

Multi-brand design systems: one core, many brands

Three brands, three design teams, three date pickers. Scaling a design system means deciding what should be the same everywhere and what should be free to differ. What to share, what to vary, and when one system becomes a family.

On this pageWhat changes when you scale
  1. What changes when you scale
  2. What to share and what to vary
  3. How brand tokens work
  4. Several platforms from one source
  5. Families of systems
  6. Governance and funding across units
  7. The short version
  8. Frequently asked questions
  9. Further reading

The short answer

A multi-brand design system shares one core (behaviour, accessibility, component structure and the names of semantic tokens) and lets each brand vary its values: palette hues, fonts, corner radius, imagery and voice. A new brand becomes a new set of token values, not a new system. Platforms work the same way: one token source, translated for web, iOS and Android, with components built natively. At large scale, one system becomes a family: a shared core with specialised systems on top.

  • Share what should be the same; make what should differ easy to differ.
  • Design the first components against your two most different brands at once.
  • Fund the shared core centrally, or it becomes nobody's job.

What changes when you scale

Scaling a design system isn't "the same thing, bigger". New kinds of difference appear: brands that must look different, platforms that must feel native, and business units with their own priorities and budgets. Each one tempts teams to start their own system.

An illustration: one group, three brands, three systems

The situation

A financial group runs a bank, an insurer and a lending app. Each brand has its own design team, and each built its own design system.

What goes wrong

Three date pickers, three accessibility fixes, three token pipelines. When a regulation changes how fees must be shown, it's implemented three times, differently.

Scaling well

One shared core (behaviour, accessibility, structure, foundations) with a brand layer on top. Each brand still looks like itself; the hard work is done once.

What to share and what to vary

LayerShared across brandsVaries by brand
BehaviourKeyboard use, focus, announcements, validation logicNothing
StructureComponent anatomy, props, patternsRarely; only through agreed extensions
Semantic tokensThe names of the jobsWhich values the names point to
ColourThe lightness curve and contrast rulesBrand hues, sometimes neutral tints
TypographyThe roles and accessibility rulesFont families, sometimes the scale
Shape and motionThe token namesCorner rounding, shadows, animation style
Imagery and voiceAccessibility rulesIllustration, photography, tone of voice
Behaviour and structure are almost always shared. Identity varies, in controlled ways, through token values.

The key move is that brands change values, not names. Every brand has color.action.primary.bg; each points it to its own palette. Because the lightness curve is shared, each brand's colours meet the same contrast rules automatically, even when their hues are completely different.

How brand tokens work

Brand palettesPrimitives per brand

Each brand has its own ramps on the shared lightness curve.

bank.brand.700insure.brand.700
→
Shared semantic layerSame names, every brand

Each brand maps the shared job names to its own primitives.

action.primary.bgtext.link
→
Shared componentsBuilt once

Components only read semantic (or component) tokens, so they restyle themselves.

Button · Input · Dialog
A brand is a set of values plugged into a shared structure. Optional component tokens let one brand restyle a specific component without forking it.

Component tokens (button.primary.container.radius) are where multi-brand systems usually need them: one brand wants pill-shaped buttons and square cards, another the reverse. See token naming for how to keep those names consistent.

In practice

Test with the most different brand first. Design the first components against your two most different brands at once, not one brand and then the other. It's much easier to find the right flexibility points while building than to add them afterwards.

Several platforms from one source

Web, iOS and Android each have their own conventions. A good multi-platform system respects them while keeping the brand recognisably the same.

One sourceToken files in the DTCG format
→
BuildA pipeline such as Style Dictionary translates them
→
OutputsCSS variables · Swift · Kotlin · Figma variables
→
Native componentsBuilt per platform, same names, props and tokens
Decide to…UsuallyExamples
ShareBrand, foundations, content, component names and purposesColours, voice, "primary button", error message formulas
AdaptThings with strong platform conventionsNavigation, date pickers, switches, text sizes, haptics
Keep separateThings that exist on one platform onlyWidgets, watch faces, desktop keyboard shortcuts

A useful test: would a regular user of this platform be surprised by how this behaves? If yes, adapt to the platform. If no, share it.

At IBM, the Riyadh Air design system drew 71 components in 13 families, each in English and Arabic, light and dark, for eight or more web and mobile apps built at the same time. See how.

Families of systems

At a certain size, one system can't sensibly hold everything. A bank's customer app, its internal tools and its marketing site have such different needs that forcing them into one library makes it worse for all three. Many large companies arrive at a family of systems:

Coretokens · base components · accessibility
Customer appsmobile patterns, onboarding
Internal toolsdense tables, admin patterns
Marketing sitespage sections, CMS blocks
Data productscharts, data grids
A family of systems. Each specialised system builds on the shared core and is owned by the teams closest to its users.

Nathan Curtis describes this as tiers below a high-quality core, and Spotify's Encore is a well-known example of bringing many separate systems under one shared structure. At CARS24, a separate system for 30+ internal tools runs alongside the consumer system, sharing the brand's foundations. Read the case study.

Governance and funding across units

  • Fund the core centrally. If every business unit pays only for its own needs, the shared core becomes nobody's job.
  • Let units own their extensions, built on the core and reviewed against its standards.
  • Have a path for absorption: when an extension component proves useful to two or more units, it moves into the core.
  • Set cross-unit decisions in one place: a small forum for changes that affect every brand, and the decision-rights matrix for the rest. See governance.
  • Measure per brand and per unit: adoption, version spread and the cost of a cross-brand change.

The short version

  • Share behaviour, structure and semantic names; vary token values per brand.
  • A shared lightness curve keeps every brand's colours accessible.
  • One token source, many platform outputs; adapt only where platform users would be surprised.
  • At large scale, use a family: a shared core with specialised systems on top.
  • Fund the core centrally and give extensions a path back into it.

Frequently asked questions

Do I need component tokens for multi-brand?

Usually yes, for a handful of properties that brands want to differ on, such as radius and button styles. Keep them to what brands genuinely need.

Can brands have different fonts?

Yes. Share the text roles (heading, body, label) and accessibility rules; let each brand map them to its own font families and, if needed, slightly different sizes.

What about white-label products?

Treat each client as a brand: map their palette into your semantic layer, then run your contrast tests on their values before release.

When does one system become a family?

When product types are so different (customer apps, internal tools, marketing) that one library serves all of them badly. Keep a shared core either way.

Further reading