All posts

How to Build a Design System in Figma, Step by Step

· Figma, Design systems

A design system is not a Figma file full of components. It is an agreement between designers and developers about how the product is built, with a Figma library as one half of it and code as the other.

That framing matters because it changes the order of work. Teams that start by drawing 80 components usually end up with a beautiful library nobody uses. Teams that start with an audit and a few decisions usually end up with something that lasts.

This is the order we follow when we build or rebuild a system for a client.

1. Audit what already exists

Before designing anything, find out what the product actually uses.

  • Colours: screenshot every screen and list every distinct colour. Most products we audit have three or four almost-identical greys and two blues that should be one.
  • Type: list every font size, weight and line height in use.
  • Spacing and radius: note the values that repeat and the ones that are clearly accidents.
  • Components: group every button, input, card and modal variant you can find. Count how many versions of each exist.
  • Code: ask developers what they already have. If there is a CSS variables file or a component library in code, your Figma system should match it, not compete with it.

The output is a short document: what to keep, what to merge and what to retire. It also tells you the real scope, which is usually smaller than people fear.

2. Decide the scope and the owner

Two questions decide whether a system survives its first year:

  • What is in version one? Foundations plus the ten components that appear on the most screens is a realistic start. Tables, charts and complex patterns can wait.
  • Who owns it? Someone has to review changes, publish updates and answer “which component do I use here?”. In a small team that might be one designer for a few hours a week. Without an owner, the library decays.

3. Build foundations as variables

Foundations are the values every component depends on: colour, type, spacing, radius, elevation. In Figma, set them up as variables:

  • A primitives collection with the raw palette and scales
  • A semantic collection that aliases primitives, with modes for light and dark if you need them
  • Number variables for spacing and radius, bound to auto layout and corners

Scope every variable and add code syntax that matches the codebase. We cover the details in our guide to Figma variables.

Type is the one foundation that still benefits from styles, because a text style bundles font, size, weight and line height. Build text styles whose properties are bound to variables, and you get the best of both.

4. Build components in priority order

Start with the components that appear on the most screens, because they give the most consistency per hour of work. For most products that is:

  1. Button and icon button
  2. Text input, select, checkbox, radio, toggle
  3. Card
  4. Navigation (top bar, sidebar or tab bar)
  5. Modal and toast
  6. List item and table row
  7. Badge, avatar, tooltip

For each component:

  • Build on auto layout so it resizes with content
  • Bind every colour, spacing and radius to a variable
  • Use variants only for real design differences like size and state
  • Use boolean, text and instance swap properties for optional and editable parts
  • Use slots for areas with flexible content, like card bodies and list items

Our article on component properties and slots goes deeper into which property to use when.

Review every component with a developer before publishing. Ten minutes of “how would you build this?” catches naming mismatches and impossible states early.

5. Document inside Figma

Documentation people actually read lives next to the components, not in a separate wiki. For each component, add:

  • A one-line description in the component itself (it appears in the assets panel and Dev Mode)
  • A usage frame showing correct and incorrect examples
  • Notes on behaviour that a static design cannot show: what happens on hover, focus, error and loading

At Config 2026, Figma announced guidelines that can be attached to published libraries, so AI agents follow existing patterns. Whether or not you use AI features, writing those rules down is now worth it twice over.

6. Publish, migrate and roll out

Publishing a library needs a paid Figma plan. Then:

  1. Migrate the most-used screens first. Swap local components for library instances and fix anything that breaks.
  2. Run a short session with the team. Show where things are, how to request a change and what not to detach.
  3. Set a release rhythm. A small update every two weeks with a short changelog beats a big release every quarter.
  4. Watch for detaches. If a component keeps getting detached, it does not fit a real use case. Fix the component, not the designer.

On Organization and Enterprise plans, Figma’s Check designs feature can flag hard-coded values, low-contrast colours and unsubscribed library items against your system. It is a useful safety net once the library is in place.

7. Plan for multiple brands and themes early

If there is any chance of a second brand, a white-label product or dark mode, design the variable structure for it now. Adding a mode later is easy; restructuring 2,000 components that use primitives directly is not.

On Enterprise plans, extended collections let you keep one core system and extend it per brand, inheriting updates while overriding values. On other plans, a mode per brand in the semantic collection works well up to the plan’s mode limit.

Mistakes we see most often

  • Starting with components instead of foundations. Every component ends up with its own colours and spacing.
  • Copying another company’s system. Material or a public UI kit is a great reference, but your product has different needs. Borrow structure, not everything.
  • No owner. The library is outdated within months.
  • Too much too soon. A system with 150 components and no documentation is harder to use than one with 15 that are clear.
  • Designing without developers. Names, states and structure that do not match code make handoff worse, not better.

How long does it take?

For a typical startup product, an audit takes about a week, foundations one to two weeks, and a core component library four to eight weeks depending on how many components and states you need. A system is never finished, but version one should be usable within two months.

If you would like help with an audit or a rebuild, that is exactly what our design system service covers. We also work white-label for agencies that need a system built for their client.

Sources

Need this done well?
We design it for you.

Tell us about your brand, product or pipeline. A 30-minute call is usually enough to know if we are a fit.