Skip to main content Scroll Top

Figma Design System: How to Build One Your Team Will Actually Use

Updated November 2026 · Written and maintained by the Progression Agency strategy team

Most product files do not lack design; they lack agreement. A Figma design system turns that agreement into files: raw values stored as variables, components that carry every state, a published library that pushes updates into every file, and a handoff where developers read token names instead of guessing hex codes. This guide builds one layer at a time, in the order the layers depend on each other, using Figma’s own documentation for each feature and the shared design token format published in 2025. Progression’s designers and front-end developers, based in New York, build these systems for companies across the US and keep them maintained after launch.

On this page · 14 sections
  1. Thirty seven blues in one product file
  2. What a Figma design system is made of
  3. Variables first: primitives, aliases and modes
  4. Styles, and when a variable is the better tool
  5. Components, variants and the properties people actually change
  6. Tokens outside Figma: the DTCG format
  7. Contrast rules belong in the color tokens
  8. Publishing the library, and how updates reach every file
  9. Handoff in Dev Mode: statuses, variables and Code Connect
  10. Governance: branches, reviews and library analytics
  11. One system, several brands
  12. Which Figma plan a design system needs
  13. What building and keeping the system costs
  14. An audit before the first token is named

Screens rather than a system? Need the screens themselves designed rather than the system behind them? Our UI/UX design services page covers app and website design in Figma.

Examples marked “Illustrative example.” describe a hypothetical software company and its product files, not a real business.

Thirty seven blues in one product file

A hypothetical software company asks a simple question before a redesign: which blue is the brand blue? A count across its four product files finds 37 slightly different blue fills, nine versions of the primary button and no record of which one is right.

Two drawn boxes. The first describes a hypothetical company with 37 slightly different blues, nine button versions and developers copying hex codes. The second describes the same files after a design system: one blue scale aliased to six tokens, one button component with variants, and token names read in Dev Mode.Two drawn boxes. The first describes a hypothetical company with 37 slightly different blues, nine button versions and developers copying hex codes. The second describes the same files after a design system: one blue scale aliased to six tokens, one button component with variants, and token names read in Dev Mode.
Illustrative example. A hypothetical product file before and after a design system.

Nobody chose 37 blues. Each one was a reasonable choice by someone working fast without a shared source. The fix is not a style guide that people read once; it is a system inside the design tool, where the right blue is the easiest one to use and changing it once changes it everywhere.

What a Figma design system is made of

In Figma’s words, a library is a collection of design assets, such as components, styles and variables, that live in one file and can be reused across other files. A Figma design system is that library plus the decisions behind it: which values exist, how they are named, who may change them and how changes reach developers.

Six labeled bands from governance at the top to variables at the bottom: governance, handoff, library, components, styles and variables, each with the Figma features that belong to it.Six labeled bands from governance at the top to variables at the bottom: governance, handoff, library, components, styles and variables, each with the Figma features that belong to it.
The six layers of the system, top to bottom.
The building blocks, and what each settles
Building blockWhat Figma says it isWhat it settles in the system
VariableA raw value, such as a color, number or string, that can change by contextEvery brand and spacing value, named once
StyleA reusable collection of properties expressed all at onceComposite looks: text, effects, layout guides
ComponentAn element reused across designs; instances follow the main componentEvery reusable piece of interface
VariantSimilar components in one set, defined by properties and valuesSizes, states and types of one component
Component propertyThe changeable parts of a component, in one panelWhat people may and may not edit
SlotA flexible area inside a component that takes any contentCards, lists and modals without detaching
LibraryComponents, styles and variables in one file, reused across filesOne source that updates every file

The order matters. Variables come first because styles and components are built from them; the library comes after the components because it publishes them; handoff and governance come last because they depend on everything below. Building the other way round is how files end up with 37 blues.

How is a design system different from a UI kit?

A UI kit is a set of drawn parts; a design system adds the rules, names and ownership that keep those parts consistent as the product grows. A kit can be downloaded in an afternoon, while a system has to fit the product, the brand and the code it will be built in.

1: Name values once. Every color, size and space lives in one variable.
2: Alias, then apply. Components use semantic tokens, never primitives.
3: States are variants. Hover, pressed and disabled sit in the set.
4: Slots over hacks. Flexible areas instead of hidden layers.
5: Describe every publish. A change note teams read before accepting.
6: One owner. A named person approves every merge.

Variables first: primitives, aliases and modes

Figma’s overview of variables describes them as raw values, like colors, numbers and strings, that can change by context, such as light and dark modes or mobile and desktop. There are six types, and a collection can hold up to 5,000 variables.

Figma’s six variable types
Variable typeHoldsTypical use in a system
ColorA color with opacityBrand palette and light and dark themes
NumberWhole or decimal numbersSpacing, corner radius, font weight, sizes
StringTextFont families, localized labels
BooleanTrue or falseShowing or hiding layers by context
TimingA duration in millisecondsOne approved animation delay and duration
EasingAn easing curve or springMotion with a consistent character

The system’s backbone is aliasing: a variable can reference another variable of the same type, which is how design tokens are built in Figma. Primitives hold the raw scale, such as blue/600. Semantic tokens such as action/primary point at a primitive. Components only ever use semantic tokens, so a rebrand changes a few aliases rather than thousands of layers.

A drawn diagram of two alias chains. Button fill points to the semantic token action primary, which resolves to blue 600 in light mode and blue 300 in dark mode. Button label points to text on action, which resolves to white in light mode and gray 900 in dark mode.A drawn diagram of two alias chains. Button fill points to the semantic token action primary, which resolves to blue 600 in light mode and blue 300 in dark mode. Button label points to text on action, which resolves to white in light mode and gray 900 in dark mode.
Illustrative example. A component uses a semantic token, which resolves to a different primitive in each mode.

Modes do the rest. Figma’s guide to modes shows one collection holding a value per mode, so a frame switches between light and dark, between languages or between watch, mobile and desktop spacing without duplicate designs. Figma also suggests modes for accessible color themes, such as a high contrast mode.

How many modes can a collection hold?

It depends on the Figma plan, and modes themselves need a Professional, Education, Organization, Government or Enterprise plan. On Enterprise, a library with a collection of at least two modes can set a default mode for the team, such as mobile spacing for an app workspace.

Can tokens come in from code?

Yes, when they follow the DTCG design token format. Figma imports design tokens as modes from JSON files in that format, which lets a team that already keeps tokens in code bring them into the design file rather than retyping them.

Styles, and when a variable is the better tool

Styles have not gone away. Figma’s guide to styles lists five kinds, color, text, effect, layout guide and animation, and a style holds a combination of values expressed all at once, such as a font family, size and weight in one text style.

Variables and styles compared, as Figma describes them
QuestionVariableStyle
What does it store?One raw value per modeA composite of values, shown together
Can it hold light and dark versions?Yes, through modesOnly when the style uses variables
Can it point at another token?Yes, aliasing works for every variable typeNo; styles cannot be applied to styles or variables
Can its use be limited to certain properties?Yes, through scopingNo
Gradients, images, blend modes?NoYes
Published in a library?YesYes

The practical split in most systems: variables hold every single value, and styles hold composites, such as a heading text style whose size and line height are themselves variables. Figma’s comparison of variables and styles confirms that variables can be applied inside styles, so the two work as one system rather than two.

  • Use a variable for any single value that could change by theme, brand or device.
  • Use a style for a composite that people apply as one choice, such as a text style.
  • Back styles with variables so a mode switch reaches them too.
  • Scope number variables so a spacing value cannot be applied as a corner radius.

Components, variants and the properties people actually change

A component is an element reused across designs: the main component defines it, and every instance receives its updates. Variants collect similar components into one set, defined by properties and values such as size and state.

A drawn grid of twelve buttons labeled Book: three sizes across, small, medium and large, and four states down, default, hover, pressed and disabled, with a note that each cell is one variant named by its size and state.A drawn grid of twelve buttons labeled Book: three sizes across, small, medium and large, and four states down, default, hover, pressed and disabled, with a note that each cell is one variant named by its size and state.
Illustrative example. A button component set with three sizes and four states.

Figma’s rules for variants are strict and worth following: every variant in a set uses the same properties, each variant is a unique combination of values, and variant names follow a Property=value pattern. Figma also cautions that adding an instance imports every variant in its set, so very large sets slow files down. Figma’s component properties decide what people may change without detaching.

Component property types, with a button example
Component propertyWhat it lets people changeExample on a button
BooleanWhether a nested layer is shownShow or hide the leading icon
Instance swapWhich nested instance is used, from preferred optionsSwap the icon for another from the set
TextWhich text content can be editedThe button label
VariantWhich variation of the component is shownSize and state
SlotA flexible area for any contentRarely on a button; common on cards and modals

When should a component use slots instead of more variants?

When the content varies more than the shape. Figma’s slots are flexible areas inside a main component where people add, resize and arrange content without detaching the instance, with preferred instances and a minimum or maximum number of layers. They suit repeating items such as task lists and freeform layouts such as cards and modals, and Figma notes they map closer to how slots behave in React.

Why do detached instances matter?

A detached instance stops receiving updates from its main component, so every fix to the system skips it. Slots, component properties and good variants all exist to make detaching unnecessary; a rising count of detached instances is the first sign a component does not fit real work.

Tokens outside Figma: the DTCG format

Design tokens also live in code, and a community of designers, developers and tool makers now publishes a shared file format for moving them. The W3C design tokens community known as the DTCG published the Design Tokens Format Module 2025.10 as a final community report on 28 October 2025.

What the Design Tokens Format Module sets
ItemWhat the format module sets
StatusA final report of a W3C community, 28 October 2025; not a W3C Standard
Media typeapplication/design-tokens+json preferred; application/json allowed
File extensions.tokens or .tokens.json
Simple typesColor, dimension, font family, font weight, duration, cubic Bézier and number
Composite typesCombinations such as shadow and stroke style, with fixed parts
ReferencesCurly braces such as {color.primary} point at another token’s value

The format exists so token data can flow between design tools, translation tools and documentation without bespoke glue code for each pair. For the system it means one token file can feed the Figma variables and the codebase, and a change in either can be checked against the other. Public systems show the same idea at scale: the U.S. Web Design System’s design tokens page describes its tokens as a limited set of discrete options, such as seven measure tokens for line length, rather than every value CSS allows.

Thirty shades of one brand color?Send the product file. You get a free proposal for a Figma design system that names every value once and pushes it everywhere.

Get a free proposalTell us about a project you’d like help with.

Contrast rules belong in the color tokens

Contrast is cheapest to get right once, at the token level, rather than screen by screen. WCAG’s contrast minimum criterion asks for at least 4.5:1 for text and 3:1 for large text, and its non-text contrast criterion asks for 3:1 for the visual parts that identify interface components and their states.

In a token system that means checking pairs, not single colors: text/default against surface/default, text/on action against action/primary, and the focus ring against every surface it can sit on, in every mode. A pair that passes in light mode can fail in dark mode, which is exactly what modes make easy to check.

  • List every foreground and background pair the components use.
  • Check each pair in every mode, including any high contrast mode.
  • Treat thresholds as hard lines; WCAG says 4.499:1 does not meet 4.5:1.
  • Check focus and selected states at 3:1 against their neighbors.
  • Record the passing pairs beside the tokens so later changes are checked too.

Publishing the library, and how updates reach every file

A component, style or variable is only usable in its own file until it is published. Figma’s publishing guide notes that the free Starter plan can create components and styles but cannot publish them as a library to other files.

Each publish asks for a description, and Figma shows that description to people when they accept the update and in the file’s version history. People using the library see a badge, review the changes and accept them when ready, and the update flows into every instance they have used. On Organization and Enterprise plans a library can be published to a specific team or the whole organization, and assets can be hidden from publishing while they are unfinished.

  1. Name the library file clearly, since the library inherits the file’s name.
  2. Hide work in progress from publishing.
  3. Write a change note on every publish: what changed and why.
  4. Publish to the teams that need it, not to everyone by default.
  5. Tell teams when an update changes something they must check.

Handoff in Dev Mode: statuses, variables and Code Connect

Figma’s Dev Mode is a developer workspace for inspecting designs, viewing properties and generated code, comparing changes and managing handoff. In a system, three of its features matter most. Designers who sketch screens as wireframes before building the library hand over cleaner work, as our guide to app design wireframes shows.

First, statuses: designers mark sections, frames and components Ready for dev, and the ready for dev view lists them in one place with when each last changed. Second, variables in Dev Mode: the variable details panel shows a variable’s collection, its value and the chain of aliases back to a raw value, and lets a developer switch modes to see the other values. Third, Code Connect links main components to the components in the codebase, through a UI inside Figma or a command line tool in the repository, and feeds those links to AI coding tools through Figma’s MCP server. On a Professional plan one library and one framework are active at a time.

The coded half of the system is front-end work in its own right; our front-end development company page covers component libraries in React and other frameworks, and React development covers the framework most systems map to.

Should developers name the tokens?

They should agree the names with the designers before the first component is built. A token named the way the code names it and shown in Dev Mode removes a translation step from every handoff.

Governance: branches, reviews and library analytics

A system without an owner drifts back to 37 blues. Figma gives the owner two tools: branching, which lets people explore changes to a library in a controlled copy, request a review and merge once approved, and library analytics, which tracks how components, styles and variables are used.

A six step flow: branch, change, review, merge, publish and accept, each with one line on what happens.A six step flow: branch, change, review, merge, publish and accept, each with one line on what happens.
Six steps from a proposed change to an update in every file.

Library analytics update daily and keep up to one year of data; Figma began tracking styles and variables on October 10, 2024. The useful questions are simple: which components are inserted most, which are never used and could be retired, and which teams have not accepted recent updates. Both tools need an Education (K-12), Organization, Government or Enterprise plan.

A drawn checklist of ten rows. Eight ticks for variables, aliases, modes, contrast, descriptions, change notes, branch reviews and code links. Two crosses: detached instances are not tracked and unused components are not retired.A drawn checklist of ten rows. Eight ticks for variables, aliases, modes, contrast, descriptions, change notes, branch reviews and code links. Two crosses: detached instances are not tracked and unused components are not retired.
Illustrative example. A hypothetical design system passes eight of ten health checks.

Who should approve a change to the system?

One named owner, with a second reviewer from engineering for anything that changes a component’s properties. Many people can propose changes on branches; few should merge them.

  • Anyone may open a branch and propose a change.
  • The owner reviews every merge into the library.
  • An engineer reviews changes to component properties.
  • Every publish carries a change note.
  • Analytics are read once a month to retire unused parts.

One system, several brands

Companies with more than one brand used to copy the whole system per brand. Figma’s extended collections let a system author create a parent variable collection and extend it for each brand, overriding only the values that differ.

A drawn card with four rows: a parent collection holding every semantic token, and three brand extensions overriding a few values each, with a closing line that anything not overridden follows the parent.A drawn card with four rows: a parent collection holding every semantic token, and three brand extensions overriding a few values each, with a closing line that anything not overridden follows the parent.
Illustrative example. A parent variable collection extended for three brands.

An extended collection inherits every update to variables it has not overridden, so a fix to the parent reaches every brand. It inherits the parent’s variable names, modes and order too, and new variables or modes can only be added in the parent. The feature needs an Education (K-12), Government or Enterprise plan.

Which Figma plan a design system needs

Most building blocks work on every plan; sharing, handoff and governance need paid ones. The table lists what Figma’s help pages state for each feature.

Figma features a design system uses, by plan
FeatureFigma plans that include it
Components, variants, component properties, slots, styles, variablesAll plans
Variable modesProfessional, Education, Organization, Government and Enterprise
Publishing a library to other filesProfessional, Education, Organization, Government and Enterprise; not Starter
Dev Mode and annotationsProfessional, Education, Organization, Government and Enterprise
Code ConnectProfessional, Education, Organization, Government and Enterprise; one active library and framework on Professional
Ready for dev viewEducation (K-12), Organization, Government and Enterprise
Branching and library analyticsEducation (K-12), Organization, Government and Enterprise
Extended collections for several brandsEducation (K-12), Government and Enterprise

A small team can build and publish a solid system on a Professional plan. Branch reviews, analytics and multi-brand collections arrive with Organization and Enterprise, which is usually when several product teams share one library.

  • Several product teams adopt the same library.
  • Changes need a review before they reach everyone.
  • Someone needs to see which components are actually used.
  • Developers want one list of designs ready for development.
  • More than one brand shares the same tokens.
  • The library should reach some teams and not others.

What building and keeping the system costs

A system is priced by how many components, modes and brands it covers, whether the coded components are built alongside, and how much of the old files must move onto it. The bands below run from the typical low to the published high in the US market.

Design system work: published US price bands (market ranges only)
WorkTypical low to published high
Design system build, Figma library with coded components$25,000 to $80,000
Full product design project, system included$10,000 to $100,000
Brand identity system the tokens start from$12,000 to $60,000
Dedicated front-end engineer to keep the coded side current$8,000 to $18,000 per month
Horizontal range bars for three kinds of project work: a design system build, a full product design project and a brand identity system.Horizontal range bars for three kinds of project work: a design system build, a full product design project and a brand identity system.
Published US price bands (market ranges only) for a design system build, a full product design project and a brand identity system, typical low to published high.

Progression sets its price in the written proposal, after scope, and it is subject to change. Design systems also appear in our product design agency guide, and branding work that feeds the color and type tokens in our SaaS branding agency page.

What does keeping a system cost after launch?

Mostly people’s time: an owner reviewing branches, a designer adding components as the product grows and a front-end developer keeping the coded components in step. A system that nobody maintains loses its value within a few releases.

Pricing depends on scope and is confirmed in a written proposal. Published prices are subject to change.

An audit before the first token is named

Before any variable is created, count what the current files actually contain. The counts set the scope and give a baseline to measure the system against.

A drawn card with six rows: colors, type, spacing, buttons, files and code, each with the count to take, and a closing line that the gap between the counts and the need is the scope.A drawn card with six rows: colors, type, spacing, buttons, files and code, each with the count to take, and a closing line that the gap between the counts and the need is the scope.
A drawn card with six counts to take before a design system is started.
  • Count distinct colors across product files.
  • Count font size and weight pairs.
  • Count spacing values in use.
  • Count button versions and detached instances.
  • List the files and teams that would adopt the library.
  • List the components that already exist in code.

Products still taking shape may want the screens designed first; our mobile app design company page covers that earlier stage, and web application development covers the build.

What this page leaves out: the Progression Method, proprietary and reserved for clients. Reach out to learn more

Frequently asked questions

What goes into a Figma design system?
Variables for every raw value, styles for composites, components with variants and properties, a published library and the rules for who changes it and how changes reach developers.
Should a new system start with components or with variables?
Start with variables. Components and styles are built from them, so naming the values first keeps every later component consistent.
How many variable types does Figma have?
Six: color, number, string, boolean, timing and easing.
How many variables can one collection hold?
Up to 5,000 variables per collection, according to Figma’s overview of variables.
What is aliasing in Figma?
It is one variable referencing another of the same type, which is how Figma implements design tokens: semantic tokens point at primitives.
When should we use a style instead of a variable?
Use a style for a composite applied as one choice, such as a text style or a gradient; use a variable for any single value that can change by mode.
Can light and dark themes share one set of designs?
Yes. Variable modes let one collection hold a value per mode, so the same frames switch between light and dark.
Do variable modes work on the free plan?
They need a Professional, Education, Organization, Government or Enterprise plan; variables themselves are available on all plans.
Can the free Starter plan publish a library?
It can create components and styles but cannot publish them as a library to other files, according to Figma.
What are slots in Figma?
They are flexible areas inside a component where people add, resize and arrange content without detaching the instance, published with the library like any component property.
Why does a large variant set slow files down?
Figma imports every variant in a set when an instance is added, so very large sets affect speed and performance.
Which shared file format do design tokens use outside Figma?
The DTCG design token format, published as the Design Tokens Format Module 2025.10, a final community report rather than a W3C Standard. Figma imports tokens written in it.
Which file extension should a token file use?
The format module recommends .tokens or .tokens.json, served as application/design-tokens+json where a media type is needed.
What contrast should color tokens meet?
WCAG asks for 4.5:1 for text, 3:1 for large text and 3:1 for the visual parts of interface components and their states.
How do developers read tokens in Dev Mode?
The variable details panel shows a variable’s collection, value and alias chain back to a raw value, and lets them switch modes to compare values.
What does Code Connect do?
It links main components in Figma to the real components in your codebase, through a UI inside Figma or a command line tool, and passes those links to AI coding tools through Figma’s MCP server.
How long does Figma keep library analytics?
Up to one year of data, updated daily, with styles and variables tracked since October 10, 2024.
Can one design system serve several brands?
Yes, on Education (K-12), Government and Enterprise plans, through extended collections that inherit the parent and override only brand values.
Who should own the system once it is live?
One named owner who approves merges, supported by an engineering reviewer and the designers who propose changes on branches.
What price range does a Figma design system build fall in?
Published US bands run from $25,000 to $80,000 for a design system build; Progression sets its price in the written proposal after scope.
Does Progression build and maintain the system after launch?
Yes. Progression’s designers and front-end developers build Figma design systems with the coded components alongside and keep them maintained, with the team based in New York and on-site sessions on request.

Thirty shades of one brand color?Send the product file. You get a free proposal for a Figma design system that names every value once and pushes it everywhere.

Get a free proposalTell us about a project you’d like help with.

Get a free marketing proposal

Tell us what you are trying to grow and we will come back with a plan, not a pitch deck. Same-day reply on weekdays.

Privacy Preferences
When you visit our website, it may store information through your browser from specific services, usually in form of cookies. Here you can change your privacy preferences. Please note that blocking some types of cookies may impact your experience on our website and the services we offer.
Contact Us