# Creating Core Components: Build the Small Set of Parts Every Screen Uses

> Learn how to pick the few UI pieces nearly every screen needs, build each one once with variants and states, and publish it so the whole team reuses it.

**In short:** Core components are the small set of UI pieces nearly every screen needs, each built once with variants and states and published so the whole team reuses it.

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

## What You Will Learn

Almost every screen in a product is built from the same small set of pieces: a button, a text box, a status mark, a menu. In a design system, the pieces that nearly every screen depends on are called core components. This lesson shows you how to choose them, build each one so it can be reused, and make it ready for the rest of your team.

By the end, you should be able to find good candidates in a product, describe the variants and states a component needs, and explain why one shared component beats many copies.

- **Component:** A reusable piece of interface, such as a button, that you build once and place many times.
- **Core component:** A component that nearly every screen uses. A design system starts with a small set of these.
- **Variant:** One version of a component, such as a small or large button, kept inside the same set as the other versions.
- **State:** How a component looks at a given moment, such as normal, hovered, focused, disabled, or showing an error.
- **Property:** A setting you can change on a component, such as its text label or whether an icon is shown.
- **Instance:** A copy of a component that stays linked to the original, so a change to the original can reach the copy.
- **Shared library:** One place where approved components are published so the whole team can use them.
- **Audit:** A review that lists what a product already has, so you can see what repeats and what differs.

## How do you decide what counts as core?

A core component is not any piece you happen to like. It earns the label for two reasons: many screens depend on it, and people would otherwise rebuild it by hand each time. Your first job is to find these pieces by looking at what the product already does.

### Why audit the screens you already have?

Start with evidence, not guesses. An audit collects the screens that exist today and lists the parts on them.

1. **Collect the main screens:** Gather the main screens of the product into one place, as screenshots or design files.
2. **List the recurring parts:** Write down every button, input, badge, and menu you see. Do not judge them yet.
3. **Group the look-alikes:** Put similar items in one row, even when their colors, sizes, or labels differ.
4. **Mark the differences:** Note where one job is done in several slightly different ways. These gaps are your first clues about what needs one shared version.

> **Tip:** Look for pieces that are almost the same. Those are the most useful finds, because one careful shared version can replace all of them.

### How do you rank candidates by use and problems?

- **How often it appears:** Parts used on many screens come first. Buttons, inputs, and navigation are common examples of this kind of high-use piece.
- **How much it varies:** A part that looks different on every screen is a priority, because one shared version can fix the mismatch quickly.
- **How costly it is to repeat:** A part that takes a long time to design again and again is worth standardizing, even if it is not used everywhere.

Work down the list from the top, and leave rare pieces for a later round.

> **Tip:** Do not try to build the whole system in one go. A small first set, such as the most used parts, is easier to get right and easier for people to adopt.

## How do you build a component to be reusable?

Once you have picked a piece, build it once as a main component, which is the original that holds the rules. Every screen then uses instances of that original. The goal is that a designer places a copy, not draws a new one.

### Why use variants for size and type?

A variant is one version of a component that sits inside a set with the other versions. Instead of keeping a small primary button and a large primary button as two unrelated files, you place both in one set and name the difference, such as size. Figma's help pages describe variant properties as the attributes that define each version, such as state, color, or size.

Keep variants for changes that really alter the look or the job. Figma-based guides suggest reserving variants for different states, types, and sizes when the look changes noticeably. For a small on-or-off change, such as an icon, a property is usually better, because otherwise the number of versions doubles every time you add an option.

### Design the States

A state is the look a component takes at one moment. Users meet these states all the time, often without noticing. A component with only the normal look leaves every other designer to guess what to draw, and that guessing creates drift. Here are the common states:

- **Default:** The normal look before anyone touches or points at the component.
- **Hover:** The look when a mouse pointer rests on it, which tells the user it can be clicked.
- **Focus:** The look when someone has moved onto it with a keyboard, so they know where they are.
- **Disabled:** The look when the action is not possible right now, often muted so the user knows it cannot be used.
- **Error:** The look when something is wrong, such as a field holding a value the product will not accept.

Many teams also design a pressed state, which shows while a user is pushing a button, and a loading state, which shows while the product is working. Figma's own best-practice guide uses a button example with normal, disabled, pressed, and focused states, which shows the idea in practice.

> **Tip:** Document every state, even the ones that feel obvious. A state that is missing from the component is usually a state that gets invented on a screen later.

### Use Properties Instead of One-Off Copies

The most common mistake is making a fresh copy whenever a button needs a different label or an icon. Each copy then becomes a small fork that nobody updates. A better way is to expose the parts that change as properties. Figma describes component properties as the changeable aspects of a component, so people can see which parts, such as icons or text, are meant to change.

- **Text property:** The label of a button can change without making a new component, so one Button serves Add, Pay, and Save.
- **Boolean property:** An icon can be switched on or off with a simple yes or no setting.
- **Instance swap property:** A different icon can be chosen from an approved list of alternatives.

Properties guide the user toward the right controls, but they do not lock other layers. So the rule is practical: if a need can be solved by a property or a state you already defined, do not create a new copy.

> **Tip:** Build small shared shapes first, then nest them inside bigger components. If the shared shape changes, every component that uses it changes too.

## Worked Example: Merging Six Add and Pay Buttons

Imagine a food delivery app with three main screens: home, cart, and checkout. This is a teaching example to show the steps. It is not a report about any real company's app. Follow the same path with any product you study.

1. **Audit the three screens:** You find six button copies. Most say Add, to put a dish in the cart, and the rest say Pay, to finish the order. Each copy has a slightly different corner curve, label size, or color.
2. **Group by job:** Sort the six copies by what they do. Pay is the main action on checkout. Add is a repeated action, and the cart version is less important than the home version.
3. **Choose the variants:** Make one Button component with two type variants: primary for the main action, and secondary for the lighter action. The label becomes a text property, so one set can say Add or Pay.
4. **Define the states:** Add default, pressed, and disabled states. Disabled is needed for Pay when the cart is empty, so the button cannot be pressed by mistake.
5. **Name and describe it:** Give the set a clear name, then write one short note: use primary for the single main action on a screen, and secondary for a lighter action.
6. **Publish and replace:** Publish the component to the shared library. Replace the six old copies one screen at a time. Later, a change to the padding is made once and reaches every instance.

> **Tip:** If an old copy cannot be swapped cleanly, write down the gap instead of making a new copy. The gap is useful evidence for the next round of work.

## Making a Component Ready for the Team

A component that only its author understands does not help anyone else. Three steps make a component usable by the team: give it a clear name, write a short note on when to use it, and publish it so changes spread.

### Give It a Clear Name and a When-to-Use Note

A name should tell a stranger what the piece is and how its versions are grouped. Name the component first, then its type and state, so the set is easy to scan. Full naming rules get their own lesson, so keep the idea simple here: a name should make sense to someone who has never met the designer.

Add a short description that says when to use the component and when not to. Figma shows these descriptions as tips when someone browses the library, so the note reaches people at the exact moment they choose a part. A note such as use secondary for lighter actions prevents most wrong picks.

### Publish It to a Shared Library

Publishing turns a working file into a shared library that other files can use. When the main component changes and is published, the instances in other files can receive that update. Figma notes that users can choose whether to accept updates or keep an older version for a while. That choice matters when a product is in the middle of a release.

Publishing also needs a few rules that keep the component locked. A short rules document can list the official variants, what does not exist, and a do-not-do list. For example, a team might say: do not make a second primary button with different padding.

- **Description:** Each main component has a short note on its purpose and owner.
- **States documented:** The default state and every critical state are shown, so no one has to guess.
- **Update trail:** The team can see when the component last changed and who approved the change.

> **Tip:** Publish only what has been reviewed. A half-finished component in the shared library gets copied by everyone, and its flaws spread with it.

## Common Mistakes to Avoid

- **Turning one idea into a core part:** A piece that appears on one screen is not yet core. Wait until the audit shows repeated use.
- **Adding a variant for every tiny change:** Sets grow fast when every small tweak becomes a version. Use properties for on-or-off changes.
- **Skipping states:** A button without disabled or error looks leaves designers to invent their own, which causes drift.
- **Keeping near-duplicates:** Two parts that do the same job, such as two dropdown-like menus with different names, confuse everyone. Merge them.
- **Publishing without a note:** A part with no description is often used in the wrong place.

## Check Your Understanding

Try these two short scenarios. Each one asks you to apply the steps from this lesson, not to repeat a sentence from it.

**Quick check:** A teammate has designed three screens. On each one, they drew a slightly different rounded rectangle with the word Save inside. Which plan is best?

A. Leave each one alone, because every screen has its own needs and the drawings are already finished.
B. Compare the three drawings, find the shared job and look, then build one Button component with the agreed variants and states, give it a when-to-use note, and publish it.
C. Keep only the Save button as a component, and let each screen change its color and corners as it needs.
D. Build three separate Save components, one per screen, so each one is easy to edit on its own.

**Answer:** B. The three drawings repeat one job, so they are a core candidate. The shared version needs defined variants and states, a clear name and note, and publication so the whole team uses the same piece.

The second scenario tests properties. Read it, then think before you look at the answer.

**Quick check:** In a new file, a designer needs the shared Button with a small arrow icon on the left. The team's Button already has primary and secondary types and default, pressed, and disabled states. What should the designer do?

A. Draw a new button from scratch in the file, so the shared Button stays untouched.
B. Duplicate the main Button, move its padding, and keep the copy only in this file.
C. Use the shared Button, switch on its icon property, and keep the existing types and states.
D. Add a fourth variant called Icon Button, then build all three states for it in the same set.

**Answer:** C. An icon that is on or off is a property, not a new type. Using the shared Button keeps one source of truth, so later fixes reach this screen too.

## Key Takeaways

Core components are the small set of shared pieces that nearly every screen depends on. Find them by auditing what already exists and ranking by use and inconsistency. Build each one once with variants for size and type, states for the moments users meet, and properties for the parts that change. Then make it ready for others with a clear name, a when-to-use note, and publication to a shared library, so one change updates every screen.

## Sources

- [Figma Best Practices: Components, styles, and shared library best practices](https://www.figma.com/best-practices/components-styles-and-shared-libraries/)
- [Figma Help Center: Create and use variants](https://help.figma.com/hc/en-us/articles/360056440594-Create-and-use-variants)
- [Figma Help Center: Explore component properties](https://help.figma.com/hc/en-us/articles/5579474826519-Explore-component-properties)
- [Figma Help Center: Components collection, Component property fundamentals](https://help.figma.com/hc/en-us/articles/39636407507735-Components-collection-Component-property-fundamentals)
- [Spaceberry: Figma components and variants, a step-by-step guide](https://spaceberry.foundation/en/guides/figma-components)
- [Lenka Studio: How to Build a Component Variant System in Figma](https://lenkastudio.com/blog/how-to-build-component-variant-system-figma)
- [Wolfpixel: How to Build a Design System, a Design Lead's Step Guide](https://www.wolfpixel.agency/blogs/how-to-build-a-design-system)
- [UX Pilot: 7 Design System Best Practices for UI](https://uxpilot.ai/blogs/design-system-best-practices)
- [Medium (Design Bootcamp): How to select the right components for your design system](https://medium.com/design-bootcamp/how-to-select-the-right-components-for-your-design-system-92d901284ee7)
- [Enspirit: Design system audit checklist for enterprise SaaS](https://enspirit.co/insights/design-system-audit-checklist)
- [AppMaster: Reusable UI components, naming, variants, and layout rules](https://appmaster.io/blog/reusable-ui-components-visual-builders)
- [ModeInspect: Design system audit, a checklist for duplicates and decoys](https://modeinspect.com/blog/design-system-audit)
