

Nobody warns you about the complexity that multiple brands add to a design system.
That's the experience of many design system practitioners who start with a clean, single-brand token structure and then watch it strain under the weight of a second brand, a third product, or a white-label requirement. The token names that made sense for one visual identity suddenly need to serve two or five or twenty, and what felt like a solid foundation reveals its limitations quickly.
The good news is that multi-brand token architecture follows a recognizable pattern, regardless of whether you're managing two brands or twenty. This article explains that pattern: the layering strategy, the decisions about what to share and what to isolate, and how the same core approach extends from multi-brand to multi-product to white-labeling.
Multi-brand, multi-product, and white-label design systems look different on the surface, but they're all variations of the same architectural challenge: how do you express multiple distinct visual identities through a single, maintainable system?
Multi-brand: Multiple brands share a common component foundation but express different visual identities. The components are the same; the colors, typography, and radii differ. A sports betting company supporting three brands, each with its own personality and color palette, is a multi-brand problem.
Multi-product: Multiple products share a design language but have different use cases, audiences, or density requirements. The visual identity is broadly shared; the token values diverge in specific, product-appropriate ways. A company with a consumer-facing app and an internal admin tool (both on brand, but with very different spacing and density needs) is a multi-product problem.
White-label: A platform operator exposes a curated set of token overrides to partners or customers, who apply their own branding within defined constraints. The system controls what can be customized and what must stay locked; partners operate within that envelope. A SaaS product with a customer-facing portal that can be rebranded for each enterprise client is a white-label problem.
All three require the same structural discipline at the token level: a stable shared foundation, a clearly defined override layer, and firm boundaries between what's shared and what's identity-specific. The difference is who controls the override layer and how wide that layer is.
The architecture that handles all three cases is a layered token hierarchy, where each layer adds specificity without disrupting the layer below it.
Global tokens → Raw values, shared across all brands
↓
Brand/product layer → Identity-specific alias overrides
↓
Component tokens → Scoped to individual components
Global tokens are the foundation. They contain the full palette, the spacing scale, the type scale: every raw value the system might ever need. Crucially, global tokens are brand-agnostic. They don't contain values that belong to any one brand; they contain the universe of values that any brand might draw from. blue-500, coral-400, neutral-900: all of these live at the global tier, regardless of which brands actually use them.
The brand layer is where identity begins. Brand tokens are alias tokens that reference the global tier and give values meaning within a specific brand's context. For Brand A, color-action-primary might resolve to blue-500. For Brand B, it resolves to coral-400. The alias name is shared; the resolution is brand-specific.
This is the layer that gets swapped when you switch brands. Components reference shared alias names; the brand layer determines what those aliases resolve to.
Component tokens sit above the brand layer and are mostly stable across brands; they reference shared alias names, so they automatically reflect whichever brand is active. Component-level overrides within a brand are rare but possible. A brand that needs its buttons fully rounded can override button-border-radius without touching any other component.
The most important architectural decision in a multi-brand system is deciding which token values are opinionated (brand-specific) and which are global (shared across all brands).
Making this decision explicitly, rather than case by case, is what allows teams to onboard new brands quickly and confidently. Without a clear framework, every new token type prompts the same question: "How is this going to look for Brand X?" With one, the answer is already encoded in the structure. The same discipline applies during rebrands, as explored in From tokens to touchpoints on the zeroheight blog.
Opinionated tokens are the defining elements of a brand: the values that make it feel distinct. They vary by brand and live in the brand layer. Common candidates:
The guiding question for opinionated tokens: would this value need to change to make the component feel like it belongs to this brand?
Global tokens are intentionally generic. They represent engineering constraints, UX patterns, and accessibility best practices that don't change between brands. Common candidates:
The guiding question for global tokens: would changing this value by brand serve a genuine identity need, or would it just introduce inconsistency?
The right balance is specific to your organization. A company whose brands are meant to feel genuinely distinct will have more opinionated tokens. A company whose brands share a strong visual family will have fewer. What matters is making the decision explicitly and encoding it in the token structure, not leaving it to individual designer judgment on each component.
The most common failure mode in multi-brand token systems is bleed: values from one brand's token layer leaking into another brand's output, or shared values becoming polluted with brand-specific assumptions.
Bleed usually happens in one of three ways:
Hardcoded global values in components: A component uses a raw global value directly (color: blue-500) instead of going through the brand alias layer (color: color-action-primary). When Brand B is active, the component still shows Brand A's blue, because it never consulted the brand layer.
Brand-specific values in the shared alias layer: A semantic alias is named after a brand's visual property rather than its role: color-surface-cobalt instead of color-surface-default. When a new brand is added, cobalt is wrong, but the alias is too specific to override cleanly.
Shared component tokens with brand-specific defaults: A component token has a hardcoded default that works for the original brand but is never overridden for subsequent brands. The second brand inherits the first brand's component decisions silently.
The structural guards against bleed:
Not every component needs to be the same across brands. The question is where to draw the line.
Start from the component, not the brand. For each component, ask: is the design variation between brands expressed entirely through token values (color, radius, font), or does the component need to be structurally different? If tokens cover it, a single shared component with a brand token layer is the right approach. If the structure itself differs (different layouts, different interaction patterns, different numbers of elements), you may need brand-specific component variants.
Most components fall into the token-expressible category. Buttons, inputs, badges, cards, and navigation elements can typically express brand identity through color, radius, and typography alone, with no structural changes.
A smaller set of components may need genuine structural variation. Brand-specific illustration styles, bespoke hero layouts, or heavily branded marketing components often can't be abstracted through tokens because the visual difference is structural, not cosmetic. These are candidates for brand-specific component variants that sit outside the shared system.
The practical rule: default to sharing components and expressing brand variation through tokens. Create brand-specific variants only when the structural difference is genuine and unavoidable.
When a system needs to support multiple products rather than multiple brands, the token architecture question shifts slightly. The visual identity is broadly shared (this isn't a different brand, it's a different context for the same brand) so the variation is narrower.
The choice to make is: modes or separate token sets?
Modes work well when the variation is systematic and limited in scope. A compact density mode that adjusts spacing and type scale for a data-heavy product, applied on top of the same brand tokens, is a clean use of modes. The mode changes a specific set of values; everything else is inherited.
Separate token sets make more sense when the variation is broader and the products are genuinely distinct in their design language, different enough that managing the differences as overrides becomes more complex than maintaining two aligned but separate token files. A consumer app and a developer portal for the same company might warrant separate token sets if their design languages diverge significantly across color, typography, and spacing.
Platform divergence (web versus iOS versus Android) is a specific multi-product case where separate token outputs are almost always necessary, even when the token source is shared. As covered in Article 04, the alias tier is the right place to handle platform-specific overrides, keeping the global source clean and generating platform-appropriate outputs through the transformation pipeline.
White-label systems introduce a distinct challenge: you're not managing variation internally, you're exposing variation to external partners who will apply their own branding. This requires a deliberate model for what partners can control and what stays locked.
The token exposure model defines the boundary between the system's locked values and the values partners can override. Designing this boundary well is the difference between a white-label system that's genuinely flexible and one that produces broken or off-brand outputs.
Locked tokens are values that reflect system-level decisions partners shouldn't override: spacing, layout, elevation, motion timing, icon geometry, accessibility-critical contrast values. These stay consistent across all tenants and aren't surfaced as overrideable.
Exposed tokens are values partners can supply: brand colors (primary, secondary, accent), typography (font family, occasionally scale), border radius, and any other brand-expression tokens the system makes available. These are documented as the partner theming API, the defined surface area for customization.
The tenant theming pattern for SaaS follows from this model. Rather than each partner maintaining a full token set, the platform defines a small set of brand variables that partners supply:
/* Partner-supplied brand variables */
brand-color-primary: #C41230
brand-color-secondary: #1A1A2E
brand-font-family: "Custom Sans", sans-serif
brand-border-radius-base: 4px
/* System resolves these into the full alias layer */
color-action-primary → brand-color-primary
color-action-primary-hover → brand-color-primary (darkened by system)
button-border-radius → brand-border-radius-base
The system does the work of resolving partner brand variables into the full alias layer. Partners don't need to understand the token hierarchy. They supply a small set of inputs and the system handles the rest. This is the model that makes white-labeling manageable at scale.
The key design question for white-label token exposure: what's the minimum set of brand variables a partner needs to supply to make the product feel like theirs? That minimum set is your exposed token surface. Everything else should be derivable by the system from those inputs.
As a multi-brand system matures, you'll eventually face the question: does a brand or product need its own system, or can it continue to be expressed through the existing one?
The case for extending (staying within the shared system):
The case for forking (a separate system):
The threshold for forking is higher than most teams expect. A lot of apparent variation is token-expressible: different colors, different radius, different typography, even different spacing scales can all live within a shared component foundation. The structural divergence that actually justifies a fork (different component anatomy, different interaction models, genuinely incompatible design languages) is less common.
When in doubt, extend. A brand that grows into a fork later is manageable. A fork taken prematurely fragments your system's value before that value has compounded.
With the multi-brand architecture in place, the next articles go deeper on two specific implementation areas.
Article 08 — Theming with design tokens covers how to structure and implement theme switching — including how to wire up CSS custom properties, scope themes at different page levels, and handle non-color tokens in a theming system.
Article 09 — Implementing dark mode with design tokens focuses on the dark mode case specifically, including why color inversion doesn't work and how to structure semantic tokens for light and dark from day one.
If you're managing multiple brands in zeroheight, Article 19 — Managing multiple brands in zeroheight covers the documentation and governance side — how to present brand-specific token sets and components in a shared styleguide.
