Rebranding with a Scalable Design System

More Than a Makeover

We didn’t just update the visual look of the app, we also built an entirely new design system. In this case study, I walk through the steps I took to create it and highlight the key benefits it brings.

Building a Scalable Design System with Semantic Tokens

When I set up the design system, my main goal was to create a foundation that was clear, flexible, and scalable. To achieve this, I used a hierarchical semantic token naming system, a structured way of naming design tokens so that their purpose is always clear and they can grow with the product over time. Instead of giving things short but vague names (like btn_primary_bg), or relying only on utility classes (like bg-primary), I wanted a system that balances clarity with flexibility. That’s where semantic token naming shines: each token name tells you what it’s for, where it’s used, and how it behaves, without needing extra documentation.

Why this matters

  • Scalability: Tokens can be expanded without breaking the structure, supporting multiple modes (e.g., dark/light) and platforms.
  • Clarity & Readability: Each token describes itself, making it easy for teams to use and understand.
  • Consistency Across the System: Aligns colors, typography, spacing, and components into one framework.
  • Flexibility & Modularity: Supports dynamic theming and variations for different states and UI contexts.
  • Developer-Friendly: Reduces hardcoded values by following predictable patterns, making integration efficient.

How the token naming works

Each token follows the same structure:

  • Collection: The category, such as color, typography, spacing, or opacity.
  • Usage: The UI element it applies to, like Fill, Border, or Content.
  • Variant: The semantic meaning, such as Primary, Secondary, or Tertiary.
  • Context: The surface it applies to (for example: on a plain background, on an accent, on a contrasting surface).
  • State: The interaction state, like Enabled, Hovered, or Disabled.

A real example

To show how this approach works in practice, let’s look at a button. Buttons are one of the more complex elements in our design system, which makes them the perfect example. Thanks to the hierarchical semantic token naming, our tertiary button can adapt seamlessly to different surfaces and states. Each token name makes it clear what the style is for and how it behaves, which keeps the system flexible and scalable.

color.fill.action.tertiary.on-base.enabled

color.fill.action.tertiary.on-plain.enabled

color.fill.action.tertiary.on-accent.enabled

color.fill.action.tertiary.on-contrast.enabled

Ideally, a single button style would work across all surfaces. In reality, though, this isn’t always possible, especially when branding guidelines and contrast requirements come into play. That’s why our tertiary button needs multiple tokens to adapt to different contexts.

Our primary button, on the other hand, is much simpler. Its design works consistently across all surfaces, so it only requires a single token. In this case, there’s no need to define the context, since the button always looks correct no matter where it’s used.

color.fill.action.primary.enabled

A glimpse of our color tokens

Wrapping up

A single button token is just one piece of the puzzle. A button doesn’t only have a background color, it also contains text, sits on an elevation, and that elevation rests on a surface. And those are only the color tokens. Our design system defines tokens for many other variables, including:

  • Colors (with support for light and dark mode, plus the ability to add accessibility themes)
  • Typography (family, weight, size, line height, spacing)
  • Border radius
  • Border width
  • Opacity
  • Spacings
  • Icon sizes

When all these tokens come together, they form a consistent, flexible, and future-proof system. At Schiphol, we manage all tokens and variables in Token Studio, which acts as the bridge between design and development. From there, tokens are exported into Figma as variables and synced with GitHub, ensuring we have a single source of truth that can be updated in one place.

The value of this approach is twofold:

  • For teams: it speeds up design and development by reducing inconsistencies and rework.
  • For users: it creates a unified, reliable experience across products and platforms. And while this case study is only a glimpse into the process, the design system itself is built to grow, adapt, and scale alongside the product.

This page only scratches the surface, there’s much more to share about the process and the benefits of building this system. I’d be happy to dive deeper and discuss it further.

event layouts and seating charts [digital project]
Featured project

Schiphol Amsterdam Airport app