Design Editor: Set Up One Shared Design System File Your Team Can Trust
Learn how a design team sets up its editor so shared styles, components, and updates stay organized, easy to share, and consistent across every designer.
In short
A design editor setup keeps one shared design system file, with shared styles, components and updates organized so every designer on the team stays consistent.
13 min readFree
What you will learn
A design system is a shared set of parts and rules that product teams reuse. The parts live in a design editor. A design editor is the software where a team draws screens and also builds, stores, and looks after the shared parts. Figma, Sketch, and Adobe XD are common examples. This lesson shows how to set up the editor so your system stays organized, easy to share, and consistent across every designer. You will also follow one worked example from a banking app, step by step.
Key words
- Design editor
- The software where designers draw screens and also build the shared parts of a design system.
- Library
- A published collection of styles and components that other files can use.
- Style
- A saved group of settings, such as a color or a text font, that you can reuse by name.
- Variable
- A named value, such as a brand color, that styles and components can read from.
- Component
- A reusable element, such as a button, that you build once and place many times.
- Main component
- The master copy of a component. It defines how the component works and looks.
- Instance
- A copy of a main component placed in a screen. It follows changes made to the master.
- Variant
- One version of a component, such as a small or disabled button, grouped under one component.
- Component property
- A setting you can change on an instance, such as its label text, without editing the master.
- Auto layout
- A rule that lines up items in a row or column and resizes the box around them when content changes.
- Constraints
- Rules that tell an object how to stay pinned to the edges of its frame when the frame is resized.
- Frame
- A box on a page that holds related design work together.
- Page
- A separate tab inside one design file.
- Publish
- The step that makes a file's styles and components available to other files.
- Branch
- A separate copy of a file where you test changes before they reach the main file.
- Changelog
- A written list of what changed in each published version.
How do you set up a design system file?
Setup comes first. Before you draw a single button, decide where the system will live and how it will be arranged. Good setup makes every later step easier, and it is much harder to fix a messy file once designers depend on it.
Why keep the library apart from product files?
Put the system in its own file. Many teams call it a library file. Keep it separate from the files where product screens are designed. A separate file keeps the shared parts clean, and it lets a small group control who can change them. Product screens then borrow the parts instead of owning them. Figma's own guide says a team can keep everything in one file as a single source of truth, or split the system into several files to suit its needs. Many teams start with one file because it is easier to manage.
Tip
Build the library in a dedicated file, never in a working design file. If a product designer is mid-project, a half-finished experiment in the library can reach every team that uses it.
Pages, frames, and names
Pages
Give each job its own page inside the file. One common layout uses a Cover page for the owner and purpose, Foundations for color, type, and spacing, Components for reusable parts, Patterns for parts combined into solutions, and a Changelog page for notes on each release.
Frames
Group related items into frames on each page. For example, put every button in one frame and every form field in another. The frame's label becomes the first part of the names of the components inside it, so label frames with clear category names.
Names
Agree on one naming pattern before you build. Figma uses a slash to create levels in names, such as Button/Primary, so related parts sort together in the Assets panel. The full naming rules get their own lesson, so for now keep names short and the same across the team.
Tip
Write the file's rules on the Cover page before anyone starts. A short note about the owner, the purpose, and the naming pattern saves hours of cleanup later.
What are the core building features for a system?
Three groups of editor features do most of the work in a system: styles and variables, components with variants and properties, and auto layout with constraints. Each group solves a different problem. Learn what each one is for before you start building.
What are shared styles and variables?
A style saves settings you want to reuse, such as a fill color, a text font, a shadow, or a grid. Figma's guide lists styles for color fills and strokes, text properties such as font and line height, shadow and blur effects, and layout grids. Variables came later. Figma launched them in June 2023. A variable holds a named value once, and styles and components can read from it. When the value changes at the source, every place that reads it can change too. What the values are and how to name them has its own lesson. Here, the focus is how the editor holds them.
What are components, variants, and properties?
A component is built once in the library and placed as instances in product screens. Figma's guide describes the main component as the master that defines the component, and the instance as the copy that receives updates made to the master.
Main component
The master. Change it once and every linked instance can follow the change after the library is published.
Variants
One component that holds many states. Instead of five separate button components, one button can hold five variants. A designer can make them by adding variants to a base component, or by combining related frames into one set.
Component properties
Settings you expose on the component, such as a text label or a switch for an icon. A designer changes these on an instance, and the master stays untouched.
Tip
Build the default state first. In Figma, the default variant is the one in the top-left corner of the set. Each other variant should differ from the default in one clear way.
Auto layout and constraints
These two rules make parts adapt. Auto layout arranges items in a line and grows or shrinks the container as the content changes. A button label can get longer without the button breaking. Constraints decide how an item behaves when its frame is resized, for example whether it stays pinned to the left edge or the right. Together they let one component fit many sizes. That is why a system should use them, instead of fixed boxes drawn by hand. One guide sums up the approach by pairing auto layout, variables, and variants for the most flexible components.
Publish and maintain the library
A library is only useful when other files can use it safely. Publishing sends the current state of the library to the team. Maintaining it keeps that state trustworthy over time. The steps below cover both.
Publish the library
- 1
Finish and check
Confirm that each style and component is complete, named, and documented before you share it. A library that no one maintains quickly becomes a burden.
- 2
Open the publish panel
In the library file, open the Assets panel, choose the library icon, and select Publish. Some guides describe the same step through the File menu and the Libraries option.
- 3
Review the list
Figma shows every style and component that will be published. Read the list and remove anything that is not ready for other people to use.
- 4
Write the change note
Describe what changed in the publish message. This message becomes your version log.
- 5
Choose who can see it
Decide whether the library is shared with one team or the whole organization. If you publish to one team only, only direct members of that team can access its styles and components. Publishing also needs edit access to the file.
Tip
Check your plan before you start.
Enable the library in product files
Designers switch a library on in each product file. The library must be published first. Then the designer opens the Assets tab, clicks the Libraries icon, searches for the library by name, opens it, and selects Add to file. Designers need at least view access to the library to use its styles, components, and variables. Team admins can also choose which libraries appear by default in team files. Adding or removing a library applies to everyone who has access to that file, so treat it as a team decision.
Receive and accept updates
When the library owner publishes a change, product files show a notice. The designer opens the review panel, which lists each change. From there, the designer can accept the update or leave it for later. Figma's team library guide says you can choose whether to accept an update, and you can apply it later. Be careful with deletions. If you delete a component in the library and publish, that component disappears from the team library.
Tip
Accept updates at a planned moment, such as the start of a short work cycle. That way the whole team works from the same version at the same time.
Versioning, change notes, and permissions
Change notes
Write a clear publish message every time. Repeat the same notes on a Changelog page, so designers can read what changed before they accept the update.
Version numbers
The team sets its own numbering, such as 1.0, 1.1, and 2.0, and writes the number into each publish message.
Branches
Test large changes in a branch, which is a separate copy of the file. Merge the branch only after review. This keeps a risky edit away from the live library.
Permissions
Limit who can publish to one or two system owners. Other designers can suggest changes, but the owners decide what reaches product files.
Upkeep
Audit the library every quarter. Archive components that no product uses, so designers only see active parts.
Worked example: a banking app library
Imagine a bank building its first design system for its mobile app. The team names the library file Banking App Design System. The example below follows the setup from the start to the first update. The brand color is only one example. The same steps work for any shared part.
- 1
Create the library file
Make one library file inside the team's design system folder. Keep it separate from the account, transfer, and card product files.
- 2
Add the pages
Create five pages: Cover, Foundations, Components, Patterns, and Changelog. Write the owner and naming rule on the Cover page.
- 3
Set the foundations
On the Foundations page, create the brand color as a variable named Color/Brand/Primary. Create text styles for headings and body text. The team stores each value once here, so the color lives in one place.
- 4
Build the Primary Button
On the Components page, in a frame labeled Buttons, build the default Primary Button. Fill its background with the brand color variable, not a color picked by eye. Add auto layout so the padding grows with the label. Add a text property so each instance can show its own label.
- 5
Add size and state variants
Create a Size property with Small, Medium, and Large options. Create a State property with Default, Hover, Disabled, and Loading options. Combining them gives twelve versions, all held by one component.
- 6
Publish version 1.0
Publish the library. Write the message as version 1.0, Primary Button added with size and state variants. Set the sharing so the whole design team can use it.
- 7
Enable it in product files
Each product designer opens their file, opens the Libraries modal, and selects Add to file for the Banking App Design System. They drag Primary Buttons from the Assets panel into their screens.
- 8
Pull in the color change
The brand team decides the brand blue is changing. The library owner edits the brand color variable on the Foundations page and publishes version 1.1 with the note brand color updated. Product designers see the update notice, open the review list, check the change, and accept it. Every Primary Button instance now shows the new color, and no one redraws a screen.
Why hand-made copies get missed
A copy is not the same as an instance. Detaching breaks the link between an instance and its main component, and a hand-made copy never had that link. If a designer copies a button from an old mockup and changes its color by hand, the button stops listening to the library. Detached parts pile up as one-off copies, and that is a known problem in design system files. When the brand color changes, the library update skips that screen completely.
Tip
When you need a different look, add a variant or a property to the library component. Do not paint over an instance. That way the change is named, shared, and updated with the rest of the system.
Check your understanding
Try these two short scenarios. Each one uses the ideas from this lesson, so you need to reason through them rather than look for the answer in a sentence.
Quick check
A teammate copies a Primary Button from an old mockup into a new screen and changes its fill to a new blue by hand. Two months later the brand color variable changes and the library is published. What happens to the new screen, and what should the teammate have done?
Quick check
A junior designer opens the team's library file the day before a release and changes the Primary Button color directly on the master. They publish without writing a message. Designers in many product files suddenly see a change they did not expect and cannot find the reason. What process would have prevented this?
Sources
- Figma Learn: Lesson 3, Build your design system
- Figma Help: Enable a library for a team
- Figma Help: Add or remove a library from a design file
- Figma Help: Share libraries in an organization
- Figma Blog: Team Libraries in Figma
- Noble Desktop: Team Libraries (Shared Libraries) in Figma
- Toptal: Consistency Is Key, How to Build a Figma Design System
- ProductHub: How to Build a Component Library in Figma
- Lenka Studio: How to Build a Component Variant System in Figma
- Lenka Studio: How to Build a Component Library in Figma for Handoff
- VantageOS: How to Set Up Design System Documentation in Figma
- UIPrep: Building a Design System 101
- Designilo: How to Create a New Library in Figma
- Think201: Figma Libraries, The Backbone of Scalable Design Systems
- UXMate: Figma Styles and Components Tutorial
- Figma Community Forum: best practices for organizing design files
Last updated on 17 November 2026
Related lessons
- Design systemsNeed of Design System: Why Teams Build Shared Parts and Rules
- Design systemsDefining Design Tokens: Named Design Decisions Shared by Designers and Builders
- Design systemsDesign Language: The Look, Feel, and Voice Behind a Design System
- Design systemsDesign System Examples: How to Read Real Systems as Models
Learn with me
Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.