# 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.

From "Design systems", a free course by Venkat R. Murty: https://designervenkat.online/learn/design-systems/design-editor

## 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.

- **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?

A. The screen updates automatically, because any copied button stays linked to the library component it came from.
B. The screen will not update, because the hand-made copy has no link to the library button or its color variable. The teammate should have placed an instance of the library Primary Button and kept its fill tied to the variable.
C. The screen updates only if the old mockup is deleted from the file, because the old file still controls the color.
D. The screen updates, but the color resets to the old default, because the editor always overwrites hand-picked colors.

**Answer:** B. Only an instance of the library component follows the master and its variable. A copy with a hand-picked color is detached, so the brand update never reaches it. The fix is to use an instance and bind the color to the variable.

**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?

A. Nothing needed to change, because the designers can undo the update in each product file one by one.
B. The change should have been made in a branch, reviewed by the system owners, and published with a clear change note by someone with publishing permission.
C. The junior should have copied the button into each product file so that no other team would be affected.
D. The junior should have renamed the button, because a renamed component is hidden from product files.

**Answer:** B. A branch lets a team test risky edits away from the live library. Limiting publishing to owners and writing a change note gives product designers a clear reason and a choice to accept or wait.

## Sources

- [Figma Learn: Lesson 3, Build your design system](https://help.figma.com/hc/en-us/articles/14548865734679-Lesson-3-Build-your-design-system)
- [Figma Help: Enable a library for a team](https://help.figma.com/hc/en-us/articles/360039234953-Enable-a-library-for-a-team)
- [Figma Help: Add or remove a library from a design file](https://help.figma.com/hc/en-us/articles/1500008731201-Add-or-remove-a-library-from-a-design-file)
- [Figma Help: Share libraries in an organization](https://help.figma.com/hc/en-us/articles/360040529593-Share-libraries-in-an-organization)
- [Figma Blog: Team Libraries in Figma](https://www.figma.com/blog/team-libraries-in-figma/)
- [Noble Desktop: Team Libraries (Shared Libraries) in Figma](https://blog.nobledesktop.com/learn/figma/team-libraries-shared-libraries)
- [Toptal: Consistency Is Key, How to Build a Figma Design System](https://www.toptal.com/designers/figma/figma-design-system)
- [ProductHub: How to Build a Component Library in Figma](https://www.producthub.dk/guides/how-to-build-a-component-library-in-figma)
- [Lenka Studio: How to Build a Component Variant System in Figma](https://lenkastudio.com/blog/how-to-build-component-variant-system-figma)
- [Lenka Studio: How to Build a Component Library in Figma for Handoff](https://lenkastudio.com/blog/how-to-build-component-library-figma-for-handoff)
- [VantageOS: How to Set Up Design System Documentation in Figma](https://www.vantageos.tech/blog/set-up-design-system-documentation-in-figma)
- [UIPrep: Building a Design System 101](https://www.uiprep.com/blog/building-a-design-system-101)
- [Designilo: How to Create a New Library in Figma](https://designilo.com/2025/07/29/how-to-create-a-new-library-in-figma/)
- [Think201: Figma Libraries, The Backbone of Scalable Design Systems](https://think201.com/blog/figma-libraries-backbone-of-scalable-design-system/)
- [UXMate: Figma Styles and Components Tutorial](https://uxmate.co.in/tutorials/figma-design-systems/)
- [Figma Community Forum: best practices for organizing design files](https://forum.figma.com/t/what-are-some-best-practices-for-organizing-design-files-in-figma/73050)
