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
- Thirty seven blues in one product file
- What a Figma design system is made of
- Variables first: primitives, aliases and modes
- Styles, and when a variable is the better tool
- Components, variants and the properties people actually change
- Tokens outside Figma: the DTCG format
- Contrast rules belong in the color tokens
- Publishing the library, and how updates reach every file
- Handoff in Dev Mode: statuses, variables and Code Connect
- Governance: branches, reviews and library analytics
- One system, several brands
- Which Figma plan a design system needs
- What building and keeping the system costs
- 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.
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.
| Building block | What Figma says it is | What it settles in the system |
|---|---|---|
| Variable | A raw value, such as a color, number or string, that can change by context | Every brand and spacing value, named once |
| Style | A reusable collection of properties expressed all at once | Composite looks: text, effects, layout guides |
| Component | An element reused across designs; instances follow the main component | Every reusable piece of interface |
| Variant | Similar components in one set, defined by properties and values | Sizes, states and types of one component |
| Component property | The changeable parts of a component, in one panel | What people may and may not edit |
| Slot | A flexible area inside a component that takes any content | Cards, lists and modals without detaching |
| Library | Components, styles and variables in one file, reused across files | One 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.
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.
| Variable type | Holds | Typical use in a system |
|---|---|---|
| Color | A color with opacity | Brand palette and light and dark themes |
| Number | Whole or decimal numbers | Spacing, corner radius, font weight, sizes |
| String | Text | Font families, localized labels |
| Boolean | True or false | Showing or hiding layers by context |
| Timing | A duration in milliseconds | One approved animation delay and duration |
| Easing | An easing curve or spring | Motion 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.
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.
| Question | Variable | Style |
|---|---|---|
| What does it store? | One raw value per mode | A composite of values, shown together |
| Can it hold light and dark versions? | Yes, through modes | Only when the style uses variables |
| Can it point at another token? | Yes, aliasing works for every variable type | No; styles cannot be applied to styles or variables |
| Can its use be limited to certain properties? | Yes, through scoping | No |
| Gradients, images, blend modes? | No | Yes |
| Published in a library? | Yes | Yes |
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.
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 | What it lets people change | Example on a button |
|---|---|---|
| Boolean | Whether a nested layer is shown | Show or hide the leading icon |
| Instance swap | Which nested instance is used, from preferred options | Swap the icon for another from the set |
| Text | Which text content can be edited | The button label |
| Variant | Which variation of the component is shown | Size and state |
| Slot | A flexible area for any content | Rarely 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.
| Item | What the format module sets |
|---|---|
| Status | A final report of a W3C community, 28 October 2025; not a W3C Standard |
| Media type | application/design-tokens+json preferred; application/json allowed |
| File extensions | .tokens or .tokens.json |
| Simple types | Color, dimension, font family, font weight, duration, cubic Bézier and number |
| Composite types | Combinations such as shadow and stroke style, with fixed parts |
| References | Curly 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.
- Name the library file clearly, since the library inherits the file’s name.
- Hide work in progress from publishing.
- Write a change note on every publish: what changed and why.
- Publish to the teams that need it, not to everyone by default.
- 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.
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.
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.
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.
| Feature | Figma plans that include it |
|---|---|
| Components, variants, component properties, slots, styles, variables | All plans |
| Variable modes | Professional, Education, Organization, Government and Enterprise |
| Publishing a library to other files | Professional, Education, Organization, Government and Enterprise; not Starter |
| Dev Mode and annotations | Professional, Education, Organization, Government and Enterprise |
| Code Connect | Professional, Education, Organization, Government and Enterprise; one active library and framework on Professional |
| Ready for dev view | Education (K-12), Organization, Government and Enterprise |
| Branching and library analytics | Education (K-12), Organization, Government and Enterprise |
| Extended collections for several brands | Education (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.
| Work | Typical 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 |
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.
- 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
Getting found in search
AI, AEO and what is changing
Paid media and lead generation
Websites and design
Choosing and working with an agency
Software and app development
Website design by industry and type
Web development, platforms and hosting
Social, content and brand
By industry and by situation
Frequently asked questions
What goes into a Figma design system?
Should a new system start with components or with variables?
How many variable types does Figma have?
How many variables can one collection hold?
What is aliasing in Figma?
When should we use a style instead of a variable?
Can light and dark themes share one set of designs?
Do variable modes work on the free plan?
Can the free Starter plan publish a library?
What are slots in Figma?
Why does a large variant set slow files down?
Which shared file format do design tokens use outside Figma?
Which file extension should a token file use?
What contrast should color tokens meet?
How do developers read tokens in Dev Mode?
What does Code Connect do?
How long does Figma keep library analytics?
Can one design system serve several brands?
Who should own the system once it is live?
What price range does a Figma design system build fall in?
Does Progression build and maintain the system after launch?
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.
