How to Make Components in Figma: Beginner’s Guide

The difference between a Figma file that stays workable and one that turns into a scavenger hunt usually comes down to a single decision: whether the repeated pieces are components or just copies. A component keeps one master version and any number of instances tied back to it. Copies keep nothing.

Product and UI designers build components inside a working file, then publish them to a team library so other files pull from the same source. Whether that effort pays off has less to do with how well the component is built and more to do with how many instances are still linked to it six months later.

Worth knowing before a library gets large: Figma’s help center sets an active memory limit of 2 gigabytes per browser tab, and recommends component properties over separate variants to stay under it (Figma Help Center, 2026).

What Is a Component in Figma?

Every component carries a master version plus any number of linked copies, which Figma calls instances. Edit the master and the instances follow. Duplicate a frame or a group instead, and you get a shape with no memory of where it came from, which is the part that bites people three weeks later.

Figma marks components with a purple outline on the canvas and a four-diamond icon in the layers panel, so they read differently from ordinary shapes at a glance.

The thinking behind this echoes atomic design, the methodology Brad Frost popularized for treating interface pieces as small, combinable building blocks rather than one-off drawings.

What a Component Is Not

A frame or a group holds shapes together, and that is all it does. There is no master-instance link underneath it, so duplicating one produces a dead copy with no connection back to the original. A component set is yet another object, since its job is to group several components into one switchable unit.

Components also sit in a different category from a wireframe or a mockup, both of which describe a stage in the design process rather than a reusable object.

Sketch calls its version of the same idea a symbol. Adobe XD calls its version a component. The concept travels across tools even when the label does not.

Figma shipped its original Components feature in December 2016, only months after the product’s first public release (The Next Web, 2016; Figma Engineering Blog, 2026). Rasmus Andersson, the designer who led the feature, modeled it on components in software engineering after working across design and engineering teams at Spotify, Facebook, and Dropbox (The Next Web, 2016).

Main Component vs Instance: What Changes and What Stays Local

Editing a main component pushes every change out to its instances immediately. An override is how you break that rule deliberately, letting one instance hold onto a local change even as the master updates around it.

What an Override Protects

Copy is the common one. Swap the label on a single instance and the font and size rules from the main component all stay put. Color overrides behave the same way, restyling one instance while every other instance keeps the master’s original. Visibility overrides are narrower than either, hiding or showing one layer on that instance alone and leaving the structure untouched everywhere else.

The mechanics of editing a component instance are where most overrides start, since changing a color or a line of copy there never reaches back to the master.

Resetting vs Detaching an Instance

Reset overrides puts the instance back to whatever the main component currently looks like and leaves the link alive for future updates. Detach instance cuts that link permanently. Nothing done to the main component afterward reaches that copy again.

Figma’s 2026 rebuild of the instance architecture made common operations in large design systems up to 50 percent faster, according to the company’s own engineering blog.

Component Properties: Text, Boolean, and Instance Swap

Component properties are the controls you expose on an instance so someone can customize it without pulling its structure apart. Figma’s documentation covers text, boolean, instance swap, variant, and slot properties, with slot the newest addition and still in open beta (Figma Help Center).

A button makes the clearest running example, and building a button in Figma from scratch is where most people run into several of these property types at once.

Boolean Properties

An on or off switch, nothing more. It toggles a nested layer’s visibility, and it shows up most often on a badge, an icon, or a helper line of text.

A checkbox component uses a boolean to switch its checkmark on and off, which saves you from building a second variant just to do that.

Text Properties

A text property exposes one text layer so the copy can change per instance while the font, size, and color stay locked to the main component.

This is the property doing most of the work in a typical button. Same idea as editing text anywhere else in Figma, only scoped down to one instance.

Instance Swap Properties

An instance swap property replaces a nested component with another one from the same file or from a connected library, without touching the parent’s main component. One icon style for another, or a light avatar variant for a dark one, are the usual cases.

Figma itself imposes no nesting depth limit. Three or four levels deep is still where files start to lag.

Variants and Component Sets

A component set is the container Figma creates when you combine separate components as variants of one another. The variant property, something like State or Size, names the axis of difference between them, and each value becomes one switchable option in the set.

Variants arrived in 2020, two years before Figma introduced dedicated component properties in 2022. Both first showed up at the company’s annual Config conference (Figma Engineering Blog, 2026).

Combining Components Into a Set

Combining works cleanly only when the groundwork is already done:

• Each state, default, hover, pressed, exists as its own separate component
• Every state shares the same layer structure, so switching never jumps the layout
• The variant property and each value get renamed from the generic Property 1 and Variant 1 defaults

Selecting those components and choosing Combine as Variants is the short version. The full click-by-click process for creating variants in Figma covers how those pieces come together.

Variants vs a Boolean or Instance Swap Property

Variants suit a major visual difference. A boolean or an instance swap suits a smaller toggle inside one design.

Reach for a variant property when you are dealing with:

• Distinct states like default, hover, focus, pressed, and disabled
• Size ranges such as small, medium, and large
• Anything that changes several layers at once

Boolean and instance swap properties cover the smaller stuff:

• Showing or hiding one icon or badge
• Swapping a single nested component without touching the rest
• Small toggles that don’t justify a whole new component in the set

A component set with dozens of variant combinations slows the file down and clutters the assets panel. That is usually the moment a smaller property wins instead.

Nested Components and the Instance Swap Property

A nested component is simply a component placed inside another one, the way an icon component often lives inside a button. The inner component keeps its own link back to its own main component, completely separate from the parent containing it.

What that separation buys you:

• Editing the icon’s own main component updates that icon everywhere it appears, including inside the button
• Editing the button’s main component can resize or restyle the frame around the icon without touching the icon itself
• An instance swap property on the button exposes the nested icon so anyone can replace it from the properties panel

Figma’s 2026 open beta for slots pushes nesting further, letting a component define flexible regions for nested content rather than one fixed nested instance (Figma Engineering Blog, 2026).

Over-nesting is the flip side. Components inside components inside components, three or four layers deep, is the most common reason a file goes sluggish or an override stops behaving the way anyone expects.

Auto Layout Inside a Component

Auto layout is what lets a component resize on its own instead of breaking when its content changes. Figma shipped it in 2019, its first real attempt at frames that react to their own contents (Figma Engineering Blog, 2026).

Hug, Fill, and Fixed Sizing

Hug contents shrinks or grows the component to match whatever sits inside it, which is why a button widens when the label gets longer. Fill container does the opposite, stretching the component to whatever room the parent frame allows. Cards spanning a full column usually want that one.

Fixed size locks the dimensions no matter what happens inside. Icons and logo marks belong here.

Padding and gap values set inside auto layout carry into every instance until someone overrides them locally, and constraints still govern anything not set to hug or fill.

The instinct behind it matches responsive design on the web. One set of rules applied consistently, instead of hand-adjusting every screen size on its own.

Switching a frame into auto layout mode and tuning these settings step by step is covered in a dedicated walkthrough on using auto layout in Figma.

How to Create a Component

Turning a selection into a component takes one keyboard shortcut. The setup beforehand is what actually matters.

1. Design the element first, as a normal frame or group, the same way you build a button, a card, or an icon
2. Select every layer that belongs inside the finished component, nothing more and nothing less
3. Press Ctrl+Alt+K on Windows or Cmd+Option+K on Mac, or right-click and choose Create Component from the menu
4. Rename the component right away, before anyone drags an instance from it
5. Drag an instance from the assets panel onto the canvas to confirm the link actually holds

The full list of shortcuts for this and every other Figma action lives in one reference on Figma’s keyboard shortcuts.

That last step, dragging from the assets panel, is really the start of using components in Figma rather than the end of making one.

How to Build Variants and Combine Components Into a Set

No special tool involved here. Just an ordered set of steps.

1. Build each state, default, hover, pressed, disabled, as its own separate component first
2. Select every one of those components at once
3. Right-click and choose Combine as Variants, or use Object, Combine as Variants from the top menu
4. Rename the variant property from Property 1 to something specific, like State
5. Rename each value from Variant 1, Variant 2, and so on to Default, Hover, Pressed
6. Drag one instance from the assets panel and switch its variant from the right sidebar to confirm every state renders correctly

Keep the layer structure identical across every state before combining. Skip that and switching variants will visibly jump the layout, which is annoying to diagnose after the fact.

Turning a full button, input, and card set into variants this way is the first real step toward a Figma design system, not a side task bolted onto one.

Naming and Organizing Components for a Library

Naming is what keeps a growing set of components usable inside the assets panel. Slash naming, writing something like Button/Primary or Icon/Chevron/Down, tells Figma to group everything after the slash into a folder automatically.

Name by function, not appearance. A name built around a color or a size falls apart the moment either one changes in a redesign, and redesigns happen.

A short component description added in the properties panel documents intended use without anyone leaving Figma to check a separate file. Most people skip this. Most people also field the same question twice a month.

The naming and organizing advice that holds up at scale is covered in a broader set of Figma components best practices.

Publishing a Component to a Team Library

Publishing turns a local component into a resource every file connected to that library can use.

Figma’s own help documentation confirms that publishing a main component, style, or variable sends a notification to every file using it, rather than forcing the change through instantly.

Updating a Published Library Without Breaking Consuming Files

Nothing about the receiving end is automatic:

• Someone publishes a change to the main component inside the library file
• Every file with an instance of that component gets a blue notification badge on the assets tab
• Each team decides whether to accept the update immediately or review it first, since nothing applies automatically

Spotify’s design systems team assembled a dedicated group in 2022 specifically to build reusable, cross-platform components for its mobile design system, Encore, after concluding that too much flexibility in earlier components had made consistency across product teams hard to maintain (Figma Blog).

Adoption is not automatic just because a library exists, though. Trust in a design system and actual use of it are two different things: 91 percent of practitioners report moderate to high trust in their system, yet only 38 percent say it is widely or fully adopted (Zeroheight Design Systems Report, 2026).

A team library only makes sense once components are stable enough to share, and publishing sits behind a paid plan rather than Figma’s free tier, a distinction covered in this comparison of Figma’s free versus professional plans.

Connecting Components to Code: Variables, Dev Mode, and Code Connect

A component’s properties only reach real code once something maps text, boolean, instance swap, and variant values to actual code props. Variables carry the values. Dev Mode hands developers the specs. Code Connect is what does the mapping itself.

• 69.8 percent of design teams already use Figma variables in their design systems (Supernova, State of Design Tokens 2024)
• More than a third of Figma’s weekly active users identify as developers rather than designers (Figma, via Computerworld reporting on Config)
• Figma shipped variables in 2023, the same platform update that made cross-file token references possible (Figma Engineering Blog, 2026)

Figma Variables and Design Tokens

A variable stores one value, a color, a spacing number, a string, that a component’s properties can reference instead of a hardcoded number.

Modes let one variable hold different values for light and dark themes, or for different breakpoints, without touching the component itself.

Changing a variable at the source updates every component referencing it. Same propagation logic that makes a main component useful in the first place.

The full mechanics of setting these up live in a dedicated Figma variables guide.

Dev Mode and Code Connect

Dev Mode gives developers a separate view of the same file, generating CSS, iOS, and Android snippets directly from a component’s properties (Computerworld, reporting on Figma’s Config announcement).

Code Connect handles the mapping work:

• A text property to a text prop in the coded component
• A boolean property to a boolean prop
• An instance swap property to whichever coded sub-component it points to

Getting out of Dev Mode when the mapping work is done, rather than just flipping a panel back and forth, is covered separately in a full Figma Dev Mode guide.

Common Mistakes That Break a Component

Most component problems trace back to repeatable mistakes, not bad design instincts.

The fastest fix for an accidental detach is hitting undo in Figma before doing anything else, since detaching is just another action sitting in the undo history.

Duplicating a main component instead of dragging an instance causes more confusion than anything else on that list. The two objects look identical on the canvas and behave nothing alike.

When a Component Does Not Apply

A component only pays off when something repeats. When nothing repeats, it is overhead.

Cases where the component route is not worth it:

• A layout appears exactly once, with no second use anywhere in the file
• The element is unique artwork, like a hero illustration or a one-off marketing graphic
• The design is still in early exploration and its structure keeps changing week to week

None of these benefit from a master-instance link, because there is no second instance to keep in sync.

Organizational readiness matters just as much as the design work. A component library assumes someone owns it, decides what gets added, and enforces the naming rules covered earlier.

Among design systems that stall after launch, 73 percent of practitioners point to the lack of a company mandate as the reason, more than any other single cause (Zeroheight Design Systems Report, 2026).

A team without that mandate is usually better off with a small, informal set of shared frames than a fully governed component library it has no authority to enforce.

FAQ on How To Make Components In Figma

Is a Figma component the same as a Sketch symbol or an Adobe XD component?

The idea is shared across tools, but the names differ. Sketch calls its reusable object a symbol, and Adobe XD calls its version a component too.

Figma’s master-instance link and override behavior don’t map exactly to either tool’s system.

Do you need a paid plan to publish a component library in Figma?

Yes. Publishing a component or component set to a team library sits behind a paid Figma plan, not the free tier.

A single file can still hold local components without publishing, but sharing across files and teams requires that upgrade.

What Should You Fix First in How To Make Components In Figma?

A Figma component that already exists inside a growing file gets fixed in a specific order: naming and governance first, structural nesting second, and variant count last, since each later fix only holds once the one before it is settled.

• Ownership and naming conventions
• Nesting depth and override cleanup
• Variant count per component set

Zeroheight’s trust and adoption figures point the same direction as its governance figure. 91 percent of practitioners trust their system, only 38 percent call it fully adopted, and 73 percent of stalled systems blame a missing company mandate.

Read together, the failure sits with organizational authority, not with the component’s design.

That same discipline is what turns one working part into creating a design system in Figma, where naming, tokens, and governance all have to hold together at once.