...

Figma Design Systems: Components, Variables and Best Practices

The core design system best practices in Figma are simple to state: store design decisions as variables in primitive and semantic collections, use modes for themes, build components with component properties and auto layout, publish them from a small number of library files, and name everything the way your code does. The goal is a Figma file that mirrors the codebase, so a designer's choice and a developer's implementation are the same decision.

This guide covers each of those practices, the trade-offs behind them and the mistakes we see most often when we take over existing files.

In short: A Figma design system works best when design tokens live in variables (primitive and semantic collections, with modes for light, dark or brand themes), components use component properties and auto layout instead of dozens of variants, libraries are published from a few well-structured files with clear versioning, and names match the code. Dev Mode then shows developers the same tokens and components they use.

 

 

Why build your design system in Figma?

 

Figma has become the default place where interface design happens, and its design system features now cover most of what a team needs: variables for tokens, components with properties, shared libraries, analytics on usage and Dev Mode for handoff. Designers, developers and product managers can all open the same file in the browser.

The tool does not make a design system on its own, though. A Figma library without matching code is a UI kit; our comparison of design system vs UI kit vs component library explains the difference. The best practices below assume Figma is one half of the system, with code as the other.

 

 

How should you structure a Figma design system?

 

Structure decides how easily the system grows. A clean setup separates what changes rarely (foundations) from what changes often (components and patterns), and keeps product work out of the library files.

How many library files do you need?

For most organisations, three levels are enough:

  1. Foundations library: variables (colour, spacing, radius, typography values), text and effect styles, icons.
  2. Components library: core components built only with foundation variables.
  3. Product files: screens and product-specific components, consuming the libraries.

Splitting foundations from components means a brand update can be published without republishing every component. Organisations with several products add product-level extension libraries on top; our guide on how to scale a design system explains when.

Inside each file, keep one page per component or component family, a cover page with the version and owner, and a changelog page. Designers should find a component in seconds.

 

 

Figma variables: how to set up design tokens

 

Point S garage-selection screen designed by Morpheon, three identical location cards built from the same component on a green background
Repeated cards built from one component: change the component or its variables once, and every instance follows

Variables are Figma's way of storing reusable values: colour, number, string and boolean. They are organised in collections, and each collection can have several modes. Used well, they are your design tokens.

Primitive and semantic collections

Create at least two collections:

  • Primitives: the raw palette and scales, such as `blue/600`, `grey/100`, `space/16`, `radius/8`. Hide these from publishing, or scope them so designers do not apply them directly.
  • Semantic (or "tokens"): values with a role, such as `color/action/primary`, `color/surface/default`, `color/text/subtle`, `space/inset/m`. Each one is an alias pointing to a primitive.

Components use only semantic variables. Use variable scoping so that a text colour variable appears only in the text colour picker, a spacing variable only in gap and padding fields. Scoping alone removes a large share of misuse.

Add code syntax to each variable (for example the CSS custom property name), so Dev Mode shows developers the exact token they should use.

Using modes for themes, brands and density

A mode is an alternative set of values for the same variables. Typical uses:

  • light and dark themes
  • several brands or white-label clients over one component set
  • density (comfortable and compact)
  • languages, using string variables for sample content

Components switch mode automatically according to the frame they sit in, so one button component renders correctly in every theme. The number of modes per collection depends on your Figma plan, so check current limits before designing a multi-brand architecture.

Variables or styles: which should you use?

Both still exist, and they do different jobs:

VariablesStyles
StoresSingle values: colour, number, string, booleanComposite values: text styles, effects (shadows, blurs), layout grids, gradients and image fills
ModesYes, for themes and brandsNo
AliasingYes, a variable can point to anotherStyles can use variables inside them
Prototyping logicYesNo
Best forColour, spacing, radius, sizes, typography valuesTypography as a whole, shadows, grids

The practical answer is to combine them: define colours and numeric values as variables, then build text and effect styles that reference those variables. You get modes and composite styles at the same time.

 

 

Figma components: best practices

 

Components are where most Figma files become hard to maintain. The aim is fewer, more flexible components that behave like their coded equivalents.

Component properties and variants

Figma offers four kinds of component property:

  • Variant: for genuine visual or structural differences, such as size (small, medium, large) or type (primary, secondary, ghost).
  • Boolean: to show or hide a layer, such as a leading icon.
  • Instance swap: to choose which nested component appears, such as which icon.
  • Text: to edit a text layer from the properties panel.

Before properties existed, teams created a variant for every combination, which led to button sets with hundreds of variants. Use variants only for differences that matter, and booleans, instance swaps and text properties for the rest. Interactive states (hover, pressed, focus, disabled) are usually variants, so they can be wired in prototypes.

Name properties exactly as the code props: if the React component has `size="sm"` and `iconLeft`, the Figma component should too. This one rule saves hours of handoff questions.

Auto layout and responsive behaviour

Build every component with auto layout, using spacing variables for padding and gaps. Set resizing to hug or fill rather than fixed widths, so components behave like flexible elements in code. Use min and max widths where a component has real limits, and test each component in a narrow and a wide container before publishing.

 

 

Publishing and governing Figma libraries

 

Publishing a library makes its components, styles and variables available to other files in your team or organisation. A few habits keep it under control:

  • Publish with a description. Figma asks for a note when you publish; treat it as a changelog entry.
  • Use branching for larger changes (available on Organization and Enterprise plans) so updates can be reviewed before they reach the main library.
  • Mark deprecated components clearly, for example with a prefix and a note pointing to the replacement, and remove them only after teams have migrated.
  • Watch library analytics (Organization and Enterprise plans) to see which components are used, where, and how often they are detached.
  • Limit who can publish. Contributions are welcome; publishing should go through the system owners.

This is the Figma side of design system maintenance: a release rhythm, a changelog and an owner.

 

 

From Figma to code: Dev Mode and handoff

 

Dev Mode is the developer view of a Figma file. It shows measurements, the variables and styles applied to each layer (with their code syntax), component properties, and status annotations such as "ready for dev". Developers can compare changes between versions of a frame.

Code Connect, available on Organization and Enterprise plans, goes a step further: it links a Figma component to the real component in your codebase, so Dev Mode shows the actual code snippet for that component, with its props, instead of generated CSS.

For handoff to work, the design and the code must share the same names, tokens and properties. That is an engineering decision as much as a design one, which is why at Morpheon our designers and engineers build the Figma library and the coded components together within our application development projects. On the ESA Solar Eclipse Trilogy platform, branding, UX/UI and full-stack development were handled by one team, so the interface designed was the interface shipped.

 

 

Figma design system best practices: a checklist

 

  • Foundations, components and product work live in separate files.
  • Every colour, spacing and radius value is a variable; nothing is hard-coded in components.
  • Primitive variables are hidden or scoped; components use semantic variables only.
  • Modes handle themes, brands and density.
  • Text and effect styles reference variables.
  • Components use auto layout with spacing variables.
  • Variants are reserved for real differences; booleans, instance swaps and text properties handle the rest.
  • Names of components, properties and variables match the code.
  • Each component page shows usage guidance, do and don't examples and accessibility notes.
  • Every publish has a description; deprecated components are labelled.
  • Library analytics are reviewed regularly.

 

 

What are the most common Figma design system mistakes?

 

  1. Hard-coded values inside components. One rebrand later, every component must be edited by hand.
  2. Variant explosion. Hundreds of variants per component make the library slow and hard to use.
  3. One giant library file. Every small change republishes everything and slows every file that uses it.
  4. Names that do not match code. Handoff becomes translation work.
  5. No owner for publishing. Anyone publishes anything, and teams stop trusting updates.
  6. Brand rules missing from the system. Colours and type come from the brand; if the brand itself is not documented, start with what a brand guidelines document should include.

If you are starting from scratch, our step-by-step guide on how to build a design system covers the process before Figma setup, from audit to first release.

 

 

Frequently asked questions

 

Can Figma variables replace design tokens?

Figma variables can hold your design tokens inside Figma, but tokens also need to reach code. Most teams keep one source of truth, either in Figma or in a token file in the repository, and sync it with the other through Figma's REST API, a plugin or a token pipeline. The important part is that only one side is edited.

Which Figma plan do you need for a design system?

Libraries with components, styles and variables are available on paid plans. Features that matter at scale, such as branching, library analytics, Code Connect and higher mode limits, are on Organization or Enterprise plans. Check Figma's current pricing page, as plan contents change.

How many modes can a variable collection have?

It depends on your Figma plan, and Figma has changed these limits over time. Check the current limits in Figma's help centre before designing a multi-brand theme architecture, especially if you need one mode per brand.

Should every component have variants?

No. Use variants for real differences in size, type or state. Use boolean properties to show or hide elements, instance swap properties for nested icons or components, and text properties for labels. A simple component with no meaningful differences needs no variants at all.

How do you keep Figma and code in sync?

Match names for components, properties and variables, generate code tokens from the same source as Figma variables, use Code Connect where available, and release design and code updates together with a shared changelog. A regular check that every Figma component has a coded counterpart catches drift early.

Is a Figma community UI kit a design system?

No. A community UI kit is a useful starting point, but it has no connection to your code, your brand or your governance. A design system adds tokens shared with code, coded components, documentation and a process for change. If you are unsure you need one, read when your company needs a design system.

 

 

Setting up or cleaning up a Figma design system?

 

At Morpheon, we build Figma design systems that mirror code, so designers and developers work from the same components, tokens and rules.

Discuss your design system

Contact us

GDPR Agreement

We store and process your personal data only to respond to your request. You can withdraw your consent at any time. For more details, please consult our privacy policy.

Non-Disclosure Agreement (NDA)

Seraphinite AcceleratorOptimized by Seraphinite Accelerator
Turns on site high speed to be attractive for people and search engines.