

The previous article introduced design tokens as named values that store design decisions. That definition is accurate, but it leaves an important question open: how do you actually organize those values so the system doesn't collapse under its own weight?
The answer is hierarchy. Most mature token systems are built in three tiers: global tokens, alias tokens, and component tokens. Each plays a distinct role. Understanding how those tiers relate to each other is the conceptual backbone of everything else in this guide: naming, architecture, multi-brand systems, and theming all depend on getting this structure right.
This article explains what each tier does, how they connect, when to use all three, and when you don't need to.
Think of a token system as a series of layers, each one adding meaning and specificity to the layer below it.
Global tokens → raw values, no implied usage
↓
Alias tokens → semantic meaning, role-based
↓
Component tokens → scoped to a single component
The flow is always downward: alias tokens reference global tokens, component tokens reference alias tokens. Values never skip upward. A component token doesn't hold a raw hex value, and a global token doesn't know which component will use it.
This separation is what gives token systems their flexibility. You can update a raw value at the global tier and have that change propagate through every alias and component that references it. You can swap what a semantic alias points to (changing your primary blue from blue-500 to blue-600) without touching a single component. The tiers decouple the decision from the delivery.
Global tokens (also called primitive tokens or raw tokens) store the raw values in your design language. They have no implied usage: they simply describe what they are.
A color palette expressed as global tokens might look like this:
json
{
"blue-100": { "value": "#EFF6FF" },
"blue-200": { "value": "#DBEAFE" },
"blue-300": { "value": "#BFDBFE" },
"blue-400": { "value": "#93C5FD" },
"blue-500": { "value": "#3B82F6" },
"blue-600": { "value": "#2563EB" },
"blue-700": { "value": "#1D4ED8" },
"blue-900": { "value": "#1E3A8A" }
}
The names are purely descriptive: blue-500 means "this shade of blue." There's no information here about where that blue is used, whether it's a button color or a background or a border. That context lives in the next tier.
Global tokens are exhaustive by design. Your color palette might have 80 or 100 values across every hue and shade you've defined. Your spacing scale might run from space-1 (4px) to space-16 (64px). These values should cover the full range of what your design language could express, not just what it currently uses.
One practical rule: global tokens should never appear directly in components. A button's background should never reference blue-500 directly. If it does, you've bypassed the semantic layer and lost the flexibility it provides.
Alias tokens (also called semantic tokens) are where design decisions become meaningful. An alias token references a global token and gives it a role: a description of where and why that value is used.
json
{
"color-action-primary": { "value": "{blue-500}" },
"color-action-primary-hover": { "value": "{blue-600}" },
"color-surface-default": { "value": "{neutral-50}" },
"color-text-primary": { "value": "{neutral-900}" },
"color-text-on-action": { "value": "{white}" },
"color-border-default": { "value": "{neutral-200}" }
}
The curly brace syntax ({blue-500}) indicates a reference: color-action-primary doesn't hold #3B82F6 directly; it points to blue-500, which holds it.
This indirection is the key to theming and multi-brand systems. If you have a dark mode, you don't rewrite any components. You swap what the alias tokens resolve to:
json
/* Light mode */
"color-surface-default": { "value": "{neutral-50}" } /* #FAFAFA */
/* Dark mode */
"color-surface-default": { "value": "{neutral-900}" } /* #171717 */
The component using color-surface-default doesn't change. Only the alias does. This is why semantic naming at the alias tier is so important. A token named color-surface-default can meaningfully resolve to different values in different contexts. A token named color-blue-light cannot.
Alias tokens are the tier that most design system work happens at. When designers and developers talk about "the primary color" or "the default surface," they're speaking in alias-tier language. Well-named alias tokens become the shared vocabulary of your team.
Component tokens are scoped to a single component. They reference alias tokens (or occasionally global tokens) and give a value a specific, localized meaning.
json
{
"button-background-default": { "value": "{color-action-primary}" },
"button-background-hover": { "value": "{color-action-primary-hover}" },
"button-text-color": { "value": "{color-text-on-action}" },
"button-border-radius": { "value": "{radius-md}" },
"button-padding-horizontal": { "value": "{space-4}" },
"button-padding-vertical": { "value": "{space-2}" }
}
Component tokens give you a local override point without touching the global or alias tiers. If your button needs a slightly different radius than the default radius-md provides, you can update button-border-radius without affecting every other component that uses radius-md.
They also make component behavior explicit and auditable. When a design or engineering review asks "what controls the button's hover state?" the answer is a named token, not a hex value buried in a CSS file.
Component tokens are optional, and not every component needs them. A simple badge or divider might reference alias tokens directly without a component-specific layer in between. The question to ask is: does this component have design decisions that are specific enough to warrant their own names? If yes, add component tokens. If not, alias tokens are fine.
The three-tier model is a pattern, not a rule. Most systems follow it closely for color, because color is where the flexibility pays off most obviously. Other categories are sometimes flatter.
All three tiers make sense when:
Two tiers (global + alias, no component tokens) work well when:
One tier (global only) is a reasonable starting point for very small systems, but it limits future flexibility significantly. You'll likely introduce aliases as the system grows.
Skipping the alias tier entirely is the most common mistake in immature token systems. When components reference global tokens directly (button-background: blue-500), you lose the semantic layer. Theming becomes painful, naming becomes inconsistent, and design intent becomes invisible. The alias tier is cheap to add and expensive to retrofit. Build it in from the start.
The three-tier hierarchy applies equally well to every category of token, not just color. Here's how each type typically works in practice.
Spacing tokens define the distances between and around elements. A global spacing scale is typically step-based:
json
"space-1": { "value": "4px" },
"space-2": { "value": "8px" },
"space-3": { "value": "12px" },
"space-4": { "value": "16px" },
"space-6": { "value": "24px" },
"space-8": { "value": "32px" }
Alias tokens give these values context: space-component-padding-sm, space-layout-gap-md. Component tokens narrow them further: card-padding, input-padding-horizontal.
Spacing tokens are particularly valuable for cross-platform consistency: the same 16px padding, properly tokenized, becomes the correct equivalent in iOS or Android rather than a developer's best guess.
Typography tokens can be simple (individual values for font size, line height, font weight) or composite (a single token that bundles all three into a named style).
Simple approach:
json
"font-size-sm": { "value": "14px" },
"font-size-md": { "value": "16px" },
"line-height-default": { "value": "1.5" },
"font-weight-regular": { "value": "400" },
"font-weight-bold": { "value": "700" }
Composite approach:
json
"type-body-md": {
"value": {
"fontFamily": "{font-family-base}",
"fontSize": "{font-size-md}",
"lineHeight": "{line-height-default}",
"fontWeight": "{font-weight-regular}"
}
}
Composite tokens are more convenient to apply but require tooling support: not every platform handles them the same way. Article 03 covers composite token support in the DTCG spec.
Radius tokens are usually a simple scale at the global tier:
json
"radius-none": { "value": "0px" },
"radius-sm": { "value": "4px" },
"radius-md": { "value": "8px" },
"radius-lg": { "value": "16px" },
"radius-full": { "value": "9999px" }
Alias tokens (radius-interactive, radius-surface) are useful if different element categories should behave differently. Most systems don't need a deep radius hierarchy. A global scale that components reference directly works well.
Shadow tokens encode elevation and depth. They're almost always composite values:
json
"shadow-sm": {
"value": {
"offsetX": "0",
"offsetY": "1px",
"blur": "3px",
"spread": "0",
"color": "rgba(0,0,0,0.12)"
}
},
"shadow-md": { ... },
"shadow-lg": { ... }
Alias tokens like shadow-card or shadow-dropdown reference global elevation values and make intent explicit for the teams consuming them.
Motion tokens are the newest addition to most systems and one of the most important for accessibility. They cover duration and easing:
json
"duration-fast": { "value": "100ms" },
"duration-default": { "value": "200ms" },
"duration-slow": { "value": "400ms" },
"easing-default": { "value": "cubic-bezier(0.4, 0, 0.2, 1)" },
"easing-enter": { "value": "cubic-bezier(0, 0, 0.2, 1)" },
"easing-exit": { "value": "cubic-bezier(0.4, 0, 1, 1)" }
Tokenizing motion matters for reduced-motion accessibility support: a system preference for reduced motion can be handled at the token tier, collapsing durations to near-zero without touching animation logic in components.
Over-tokenizing: Creating a token for every conceivable value, including one-off decisions that genuinely don't repeat. Token systems have maintenance overhead; every token you add is a token someone has to name, document, and govern. Not every value needs a token.
Under-tokenizing: Skipping the alias tier and letting components reference global tokens directly. This feels like a shortcut but creates rigid systems that are painful to theme and expensive to update at scale.
Flattening the hierarchy: Putting raw values directly into alias tokens (e.g. color-action-primary: #3B82F6) instead of referencing a global token. You lose the connection between palette and usage, and end up with multiple tokens holding the same raw value with no shared source.
Semantic names that aren't semantic: Alias tokens named color-blue-dark or color-text-grey that describe the color rather than the role. When dark mode arrives, color-text-grey resolves to something light, and the name becomes actively misleading.
Creating component tokens too early: Defining exhaustive component-level tokens before you understand which design decisions are actually component-specific. Start with alias tokens in components; introduce component tokens when you have a real reason to override them.
With the three tiers in place, the next questions are: how many tiers do you actually need, what should you tokenize versus leave hardcoded, and how do you make decisions that hold up as the system grows?
That's the territory of Article 04 — Token architecture: building a scalable token system, which goes into the structural decisions in depth.
If you want to understand how to make alias and component token names consistent and meaningful, Article 05 — Naming your design tokens picks up directly from here.
And if you're working in Figma and want to see how collections, groups, and variable types map to this three-tier model, Article 14 — Setting up design tokens in Figma: variables, collections and modes covers that in full.
For a practical real-world example of how one team brought their color token hierarchy in sync across design and code, the zeroheight blog post How we got our color tokens in sync is a useful companion read.
