...

How to Scale a Design System Across Multiple Products

To scale a design system across multiple products, separate brand decisions from components. Store colours, type and spacing as tiered design tokens, theme each product on top of a shared core, agree who builds and approves what, release changes with clear versions, and measure adoption. Components then travel between products, and only the decisions that genuinely differ are made twice.

Most systems start inside one product. If you are still at that stage, our guide on how to build a design system covers the foundations. This article is about the next step: one system, several products, several teams.

In short: Scaling a design system means making one set of foundations serve several products, brands, platforms and teams without forks. It rests on three things: a token architecture that keeps brand values out of components, a governance model that defines who builds, reviews and releases, and versioned releases with adoption metrics. Without governance, a larger system only fragments faster.

 

 

What does it mean to scale a design system?

 

A design system scales along four dimensions, and most organisations hit them in this order:

  • Products: a second app, a customer portal, an internal tool.
  • Brands: a sub-brand, an acquired company, a white-label offer for partners.
  • Platforms: web, iOS and Android, sometimes kiosks or TV.
  • Teams: more squads, external agencies and freelancers working in parallel.

Each dimension puts a different strain on the system. More products test whether components are generic enough. More brands test whether styling is separated from structure. More teams test governance.

Signs your design system has outgrown its first product

You usually see the problem before anyone names it:

  • teams detach library components to change one colour or one padding value
  • the same button exists three times, in three slightly different blues
  • a second product copied the library file and now drifts on its own
  • nobody knows which version of a component is current in code
  • every change needs the one person who built the system

These are not failures of discipline. They show that the system was built for one product, with brand values baked directly into components and no process for anyone else to contribute. A short design system audit maps how far the drift has gone before you restructure.

 

 

How do you structure a design system for multiple products?

 

The structural decision that makes scaling cheap is to stop hard-coding brand values in components. A button should know it uses "the primary action colour", not "#6F02F4".

Separate tokens into tiers (primitive, semantic, component)

Design tokens are named design decisions stored as data, so design tools and code read the same values. At scale, three tiers work well:

  1. Primitive tokens: the raw palette and scales. `blue-600`, `space-16`, `font-size-20`. They carry no meaning.
  2. Semantic tokens: the role a value plays. `color-action-primary`, `color-surface-default`, `space-inset-m`. Components only use these.
  3. Component tokens (optional): overrides for one component, such as `button-radius`. Use them sparingly; too many and the system becomes impossible to reason about.

The benefit is direct. To launch a new brand, you change which primitives the semantic tokens point to. Hundreds of components update without being touched.

Use theming for brands and products

A theme is a set of values for the semantic tokens: brand A, brand B, light mode, dark mode, high contrast. In Figma this maps to variable collections and modes; in code, to CSS custom properties or platform-specific token files generated from one source. Our guide to Figma design systems explains how variables and modes support this.

Theming is also where brand and product meet. Brand guidelines define the palette and typography; the design system decides how those values behave in interfaces. If the brand side is not documented yet, start with what a brand guidelines document should include.

Keep a shared core and product-specific extensions

Not everything belongs in the shared system. A useful rule: a component enters the core when at least two products need it in the same form. Until then, it lives in the product's own extension library, built with the core tokens so it can be promoted later without rework.

  • Core: foundations, tokens, buttons, inputs, navigation patterns, feedback, layout primitives.
  • Extensions: domain components such as a booking calendar, a pricing configurator or a data visualisation set.

 

 

Which governance model works best when you scale?

 

Point S multilingual registration web app shown as several mobile screens sharing one set of components on a blue background
Several screens, one set of components: consistency comes from shared rules, not from repetition

Scaling a design system is mostly an organisational problem. The technical structure above only holds if everyone knows who decides. There are three common models:

CentralisedFederatedHybrid
Who buildsA dedicated system teamProduct teams, coordinated by a small groupA core team plus contributors from product teams
Speed for product teamsSlower: requests queueFastFast for extensions, reviewed for core
ConsistencyHighLower without strong reviewHigh in the core
Main riskBottleneck, system drifts from real needsFragmentationNeeds clear contribution rules
Best forOne or two products, early systemMature teams with strong design cultureMost organisations with three or more products

For most organisations scaling beyond two products, a hybrid model works best: a small core team owns foundations and quality, and product teams contribute what they discover.

How should teams contribute new components?

Write the contribution process down and keep it short:

  1. Check first. Search the library and the backlog; many "new" components are variants of existing ones.
  2. Propose. A short request: the problem, where it appears, a first design.
  3. Review. The core team checks accessibility, token use, naming and overlap.
  4. Build in both places. Design and code are released together, or the component is not done.
  5. Document and announce. Usage guidance, do and don't examples, a release note.

Contributions are how a system stays relevant. A core team that refuses them ends up maintaining a library nobody uses; one that accepts everything ends up with three date pickers.

 

 

How to scale a design system: a step-by-step plan

 

  1. Audit what exists. Inventory components, tokens, forks and detached instances in every product.
  2. Define the shared core. Agree which foundations and components every product will use.
  3. Restructure tokens into tiers. Move hard-coded values to semantic tokens before adding new brands.
  4. Set up theming. One theme per brand or product, plus modes such as dark or high contrast where needed.
  5. Agree governance and contribution. Name the core team, the reviewers and the decision rules.
  6. Version and release. Use semantic versioning (major, minor, patch), changelogs and a deprecation period for breaking changes.
  7. Measure adoption. Track usage per product and act on the gaps.

Migrate products one at a time, starting with the one that will benefit most. A big-bang migration of every product at once rarely survives contact with roadmaps.

 

 

How do you measure whether your design system is scaling?

 

Choose a handful of indicators and review them every quarter:

  • Adoption: share of screens or code modules built with system components, per product.
  • Detachments and overrides: how often designers detach components in Figma, and where. Figma's library analytics shows this on Organization and Enterprise plans.
  • Version lag: how many releases behind each product runs.
  • Time to ship: how long a standard screen or feature takes, before and after adoption.
  • Accessibility defects: issues found in testing that trace back to components.
  • Contributions: proposals received from product teams and accepted.

Read the numbers as signals, not targets. A high detachment rate on one component usually means the component is missing a variant, not that teams are careless.

 

 

What are the most common mistakes when scaling a design system?

 

  1. Scaling before restructuring. Adding a second brand to a system with hard-coded values multiplies the work.
  2. Treating the system as a design file. If code does not ship the same components, the system exists only in Figma.
  3. No owner. Without a named team and budget, the system decays; see design system maintenance for the costs and routines involved.
  4. Over-generalising. Making every component configurable for every possible product produces components that are hard to use for any of them.
  5. Breaking changes without warning. One silent update that breaks three products destroys trust in the system for months.

 

 

Should you scale your design system in-house or with a partner?

 

Scaling in-house works when you have a design system lead, front-end engineers with time allocated to the system and leadership support for governance. A partner helps when the restructuring is a project in itself: a token migration, a multi-brand theming layer, or a new platform added under deadline.

On the ESA Solar Eclipse Trilogy platform, we handled branding, UX/UI, cloud infrastructure and full-stack development as one team. The platform was engineered for more than one million simultaneous users and published in several languages, and it remains under a maintenance contract. Keeping identity, interface and code in one system is what let it grow without separate visual languages appearing.

At Morpheon, we treat a design system as product infrastructure, designed and engineered alongside the web and mobile products it serves. For budgets, our guide to design system cost gives market ranges, and our engagement models show how a project or an ongoing partnership is structured.

 

 

Frequently asked questions

 

When should a design system support multiple brands?

When two or more brands share products, teams or a codebase, for example after an acquisition or when launching a sub-brand. If the brands share interaction patterns but differ in colour, type and tone, theming over one shared core is far cheaper than maintaining separate systems. If the products have nothing in common, separate systems may be simpler.

How many people does it take to scale a design system?

It depends on the number of products and platforms. A common starting point is a small core team of one or two designers and one or two front-end engineers, with part-time contributors in each product team. What matters most is that their time on the system is protected, not borrowed from product deadlines.

Should web and mobile share one design system?

They should share foundations: tokens, principles, naming and accessibility rules. Components often differ, because iOS and Android have their own interface conventions. A practical approach is one token source that generates values for each platform, with platform-specific component libraries built on top.

How do you version a design system?

Use semantic versioning. Patch releases fix bugs, minor releases add components or variants without breaking anything, and major releases introduce breaking changes. Publish a changelog with every release, mark deprecated components clearly and give product teams a migration window before removing them.

Can a design system scale without design tokens?

Only up to a point. Without tokens, every brand or theme change means editing components one by one, in design and in code. For a single product this is manageable. Across several products or brands, tokens are the mechanism that keeps changes to one place.

How long does it take to scale a design system?

Restructuring tokens and setting up theming for an existing system typically takes weeks to a few months, depending on its size and the state of the code. Migrating every product is longer and usually runs alongside product roadmaps, one product at a time. An audit first gives a realistic estimate.

 

 

Scaling a design system across several products?

 

At Morpheon, we design and engineer design systems as product infrastructure: tokens, components and governance that hold up as your products, brands and teams grow.

Discuss your design system

Contact us

GDPR Agreement

We store and process your personal data only to respond to your request. You can withdraw your consent at any time. For more details, please consult our privacy policy.

Non-Disclosure Agreement (NDA)

Seraphinite AcceleratorOptimized by Seraphinite Accelerator
Turns on site high speed to be attractive for people and search engines.