Design7 min read

Design systems that scale: from Figma tokens to production components

A design system only scales when design and code share the same source of truth. Here is how to structure tokens, build components and govern the system as products grow.

By INFIDEC Product Design Team

Cover: design systems with Figma and React

Why design systems stall

Most design systems start well: a Figma library, a set of React components and a burst of enthusiasm. A year later, the Figma file and the codebase have drifted apart, product teams build their own variants, and nobody is sure which button is the real one.

The underlying problem is usually that design and code have separate sources of truth, kept in sync by hand. A scalable system makes the shared decisions explicit as tokens, generates platform code from them automatically, and gives components clear ownership and a release process.

Structure tokens in tiers

Design tokens are named design decisions such as colours, spacing, type scales, radii and motion durations. Organising them in tiers keeps the system flexible without becoming chaotic.

  • Primitive tokens hold raw values, such as blue-600 or space-4. They describe what a value is, not where it is used.
  • Semantic tokens describe intent, such as color-text-primary, color-surface-raised or color-border-danger, and reference primitives.
  • Component tokens, where needed, describe specific parts, such as button-primary-background, and reference semantic tokens.
  • Product code should mostly use semantic tokens. That is what makes theming, dark mode and rebrands a matter of changing references rather than editing components.

Model tokens in Figma with variables and modes

Figma variables map well to this structure. Keep primitives in one collection, semantic tokens in another that alias the primitives, and use modes for light and dark themes, brands or density. Designers then apply semantic variables to their designs, so a theme switch in Figma behaves the same way it will in code.

Agree on naming before you create hundreds of variables. Names should be predictable, consistent between Figma and code, and free of visual descriptions in the semantic tier, since "text-blue" stops making sense the day the brand colour changes.

Automate the path from Figma to code

Tokens should flow into code through a pipeline, not through someone copying hex values. A common setup exports variables to JSON, ideally in the W3C Design Tokens Community Group format, and commits them to the design system repository, either through a plugin or the Figma REST API.

A build tool such as Style Dictionary then transforms the JSON into the formats each platform needs: CSS custom properties, a Tailwind theme, Swift and Kotlin constants, or Android resources. Changes arrive as pull requests, so engineers can review the diff, run visual tests and release the update like any other dependency.

Build components for accessibility and composition

Components are where the system earns its keep, so build them to be reused rather than to match one screen.

  • Start from accessible primitives, such as Radix UI or React Aria, rather than rebuilding focus management and keyboard behaviour for menus, dialogs and comboboxes.
  • Prefer composition over long prop lists. A card made of header, body and footer slots handles more cases than one with twenty boolean props.
  • Express variants explicitly and keep them aligned with Figma component properties, so a designer's variant maps to exactly one code variant.
  • Use only tokens for visual values inside components, and lint for hard-coded colours and spacing.
  • Document every component in Storybook with usage guidance, and run automated accessibility checks with axe and visual regression tests on each change.

Keep design and code connected day to day

Tokens and components are only half of the link between design and code. The other half is the daily workflow. Figma Code Connect, or a similar convention, lets developers inspecting a design see the actual component and props to use rather than a generated approximation, which removes a common source of drift.

Run regular parity checks between the Figma library and the coded components: same names, same variants, same states, same token references. Where they differ, decide which one is right and fix the other, rather than letting both versions live on. It also helps to pair a designer and an engineer as joint owners of each component family, so changes are discussed once and shipped in both places together.

Governance keeps the system alive

A design system is a product with internal customers, and it needs the same things as any product: an owner, a roadmap and a way to take feedback. Publish components as versioned packages using semantic versioning, write changelogs, and provide migration notes or codemods for breaking changes.

Define a contribution model so product teams can propose new components or variants instead of building one-offs. Track adoption, for example the share of UI built from system components and the number of local overrides, to see where the system is not meeting teams' needs. When adoption is low, treat it as feedback about the system rather than a compliance problem.

Strategy

How much does custom software development cost in 2026?

There is no single price for custom software, but there is a reliable way to estimate it. Here are the factors that drive cost, how engagement models differ, and how to reduce budget risk.

7 min read

Have a product to build or a system to fix?

Tell us where you are and what you need. A senior engineer replies within 24 hours with next steps, not a sales script.