Popular Searches
Popular Course Categories
Popular Courses

Component Variants

Component Variants

Components & Variants

Component Variants in Figma

Component Variants in Figma are different versions of similar components grouped together inside a single component set. They are useful when a component needs predictable variations such as different states, sizes, types, colors, themes, or layouts. Instead of maintaining many separate components, designers can organize related versions into one structured system and allow users to switch between them through variant properties.

For professional Figma design-system training, explore JustAcademy Figma Training and Register for Figma Course Demo.


1. What are Component Variants?

A Component Variant is a specific version of a component that differs from other versions in predictable ways. Multiple related components can be combined into a component set, where variant properties define the differences between them.

For example, a button may have Primary, Secondary, Small, Large, Hover, Pressed, and Disabled versions. These can be organized as variants instead of being maintained as completely separate components.


2. Simple Definition

Component Variants are related versions of a reusable component organized inside one component set.

Button Component Set
├── Primary
├── Secondary
├── Disabled
├── Hover
└── Pressed

3. Why are Component Variants Important?

Large design systems can contain hundreds or thousands of components. Without a proper variant system, similar components can become difficult to find and maintain. Variants group related components into an organized structure and make them easier to use.

  • Reduce component-library clutter.
  • Group related components.
  • Make component selection easier.
  • Represent different component states.
  • Represent different sizes and types.
  • Improve design consistency.
  • Make design systems easier to maintain.
  • Improve designer and developer collaboration.
  • Make component instances easier to configure.
  • Support scalable design-system workflows.

4. Component Variant Structure

Component Set
│
├── Variant 1
│   ├── Type = Primary
│   ├── Size = Small
│   └── State = Default
│
├── Variant 2
│   ├── Type = Primary
│   ├── Size = Medium
│   └── State = Hover
│
├── Variant 3
│   ├── Type = Secondary
│   ├── Size = Large
│   └── State = Default
│
└── Variant 4
    ├── Type = Destructive
    ├── Size = Medium
    └── State = Disabled

5. What is a Component Set?

A component set is a container that groups related component variants. When components are combined as variants, Figma places them inside a component set. The component set is displayed on the canvas with a dashed purple boundary by default.

A component set helps designers treat many related component versions as one organized component family.


6. Component vs Component Variant

Component Component Variant
Reusable design object Specific version of a reusable component
Can exist independently Usually belongs to a component set
Represents a reusable UI element Represents a predictable variation
Example: Button Example: Button / Primary / Large

7. What is a Variant Property?

A variant property defines an attribute by which variants differ. Common variant properties include Type, Size, State, Color, Theme, Density, and Orientation.

Property: Size
 
Values:
Small
Medium
Large

8. What is a Variant Value?

A variant value is a specific option belonging to a variant property.

Property: State
 
Values:
Default
Hover
Pressed
Disabled

Here, State is the property and Default, Hover, Pressed, and Disabled are its values.


9. Variant Properties and Values

Property Possible Values
Type Primary, Secondary, Tertiary
Size Small, Medium, Large
State Default, Hover, Pressed, Disabled
Theme Light, Dark
Density Compact, Comfortable

10. When Should You Use Variants?

Use variants when multiple versions of a component serve the same general purpose and differ in predictable ways.

  • Button states.
  • Button sizes.
  • Input states.
  • Navigation states.
  • Checkbox states.
  • Radio-button states.
  • Toggle states.
  • Badge types.
  • Card styles.
  • Component themes.

11. When Should You Avoid Variants?

Not every customization should become a variant. If the difference can be handled more effectively with another component property or layout feature, use that approach instead.

  • Use Boolean properties for simple show/hide behavior.
  • Use Text properties for editable text.
  • Use Instance Swap for replaceable nested components.
  • Use Slots for flexible content areas.
  • Use Auto Layout for automatic spacing and resizing.

12. Common Component Variant Examples

Component Possible Variants
Button Primary, Secondary, Disabled, Hover
Input Default, Focus, Error, Success, Disabled
Checkbox Unchecked, Checked, Indeterminate, Disabled
Navigation Item Default, Hover, Active, Disabled
Badge Success, Warning, Error, Information
Card Default, Featured, Compact, Large

13. Creating Components Before Variants

Before creating variants, you can create the individual components that represent the required variations.

  1. Design the base component.
  2. Convert the design into a component.
  3. Duplicate the component for required variations.
  4. Modify each component.
  5. Select the related components.
  6. Combine them as variants.

14. How to Combine Components as Variants

  1. Select the components you want to combine.
  2. Go to the right sidebar.
  3. Click Combine as variants.
  4. Figma creates a component set.
  5. Review the generated variant properties.
  6. Rename the properties with meaningful names.
  7. Review the variant values.
  8. Organize the variants on the canvas.

15. Creating a New Variant

You can create a new variant from an existing component or component set.

  1. Select a main component.
  2. Use the variant controls in the right sidebar.
  3. Add a new variant.
  4. Figma creates the additional variant inside a component set.
  5. Modify the new variant as required.
  6. Assign appropriate property values.

16. Adding More Variants

Once a component set exists, you can continue adding variants to it. You can create additional variants, duplicate an existing variant, or add other related components to the component set.

Existing Component Set
        ↓
Add Variant
        ↓
Duplicate Variant
        ↓
Modify Design
        ↓
Assign Property Values
        ↓
New Variant

17. Example: Button Component Set

A professional button component set may use three major variant properties.

Button
 
Type:
Primary
Secondary
Destructive
 
Size:
Small
Medium
Large
 
State:
Default
Hover
Pressed
Disabled

18. Button Variant Matrix

Type Size State
Primary Small Default
Primary Medium Hover
Primary Large Pressed
Secondary Medium Default
Destructive Large Disabled

19. Naming Component Variants

Good naming is essential for a scalable design system. Property names should clearly communicate the dimension of variation.

Good example:

Type = Primary
Size = Large
State = Hover

Poor example:

Property 1 = A
Property 2 = B
Property 3 = C

20. Slash Naming Convention

Figma supports slash-based naming to organize components and help convert existing components into variants.

Button/Primary/Large/Default
Button/Secondary/Medium/Hover
Button/Destructive/Small/Disabled

The first part can become the component set name, while the following parts can become variant property values when the components are combined as variants.


21. Slash Naming Example

Button/Primary/Large/Default

This can be interpreted as:

  • Component Set = Button
  • Type = Primary
  • Size = Large
  • State = Default

22. Important Slash Naming Rule

When converting existing components into variants using slash naming, keep the naming structure consistent. The components being combined should use the same number of slash-separated levels so that the generated properties and values remain consistent.


23. Renaming Variant Properties

Figma may initially create generic property names such as Variant, Property 2, and Property 3 when converting components. These should be renamed to meaningful names.

  1. Select the component set.
  2. Find the Properties section in the right sidebar.
  3. Select or edit the property name.
  4. Rename it to describe its purpose.
  5. Repeat for the remaining properties.

24. Good Variant Property Names

  • Type
  • Size
  • State
  • Color
  • Theme
  • Density
  • Orientation
  • Emphasis

25. Poor Variant Property Names

  • Property 1
  • Property 2
  • Option A
  • Version 1
  • New
  • Test
  • Thing

26. Variants for Button States

Buttons frequently require multiple interaction states.

Button
├── Default
├── Hover
├── Pressed
├── Focus
└── Disabled

The State property can be used to organize these predictable states.


27. Variants for Different Sizes

Variants can represent predefined component sizes.

Size
├── Small
├── Medium
└── Large

Each size can have appropriate typography, padding, height, icon spacing, and other design characteristics.


28. Variants for Different Types

Buttons and other controls may have different semantic or visual types.

Type
├── Primary
├── Secondary
├── Tertiary
└── Destructive

29. Variants for Different Themes

Variants can represent meaningful theme differences when distinct component versions are required.

Theme
├── Light
└── Dark

For broader design-token management, variables can also be used alongside components and variants.


30. Variants for Navigation Items

Navigation Item
├── Default
├── Hover
├── Active
├── Selected
└── Disabled

31. Variants for Input Fields

Variant Purpose
Default Normal input state
Focus Input is currently selected
Filled Input contains content
Error Input contains invalid data
Success Input contains valid data
Disabled Input cannot be edited

32. Variants for Cards

Card
├── Standard
├── Featured
├── Compact
├── Horizontal
└── Disabled

33. Variants for Badges

Badge
├── Success
├── Warning
├── Error
├── Information
└── Neutral

34. Variants for Checkboxes

Checkbox
├── Unchecked
├── Checked
├── Indeterminate
├── Disabled
└── Error

35. Variants for Radio Buttons

Radio
├── Unselected
├── Selected
├── Disabled
└── Error

36. Variants for Toggle Controls

Toggle
├── Off
├── On
├── Off Disabled
└── On Disabled

For a scalable design system, consider separating concepts such as state and disabled status into separate properties when that produces a clearer and more reusable architecture.


37. Variants for Tabs

Tab
├── Active
├── Inactive
├── Hover
└── Disabled

38. Variants for Menu Items

Menu Item
├── Default
├── Hover
├── Selected
├── Active
└── Disabled

39. Variants and Instances

A component-set instance allows designers to select different variant values without manually recreating the component. When an instance of a component set is placed on the canvas, its properties can be configured from the right sidebar.

Component Set
      ↓
Create Instance
      ↓
Select Instance
      ↓
Configure Properties
      ↓
Choose Variant
      ↓
Updated Instance

40. Using Variants from the Assets Panel

  1. Open the Assets panel.
  2. Find the required component set.
  3. Drag the component set onto the canvas.
  4. Figma creates an instance using the default variant.
  5. Select the instance.
  6. Use the variant properties in the right sidebar.
  7. Select the required values.

41. Default Variant

Figma uses the variant in the top-left position of a component set as the default variant. This variant represents the component set in the Assets panel and is used when the component set is initially inserted into a design.

Therefore, place the most useful or commonly used variant in the top-left position.


42. Organizing Variants on the Canvas

When a component set contains many variants, organize them into rows, columns, or grids so that the structure is easy to understand.

  • Group similar values together.
  • Use consistent spacing.
  • Arrange related states in the same row.
  • Arrange related sizes in columns.
  • Use annotations when useful.
  • Keep the component set visually clean.

43. Example Variant Grid

              Small       Medium       Large
 
Primary       Default     Default      Default
Primary       Hover       Hover        Hover
Primary       Pressed     Pressed      Pressed
Primary       Disabled    Disabled     Disabled
 
Secondary     Default     Default      Default
Secondary     Hover       Hover        Hover
Secondary     Disabled    Disabled     Disabled

44. Unique Variant Combinations

Every variant in a component set should have a unique combination of property values. Two variants cannot have the exact same property-value combination, even if they look visually different.

Type = Primary
Size = Large
State = Default

If another variant uses the same combination, Figma will report a conflicting value combination.


45. Fixing Conflicting Variant Values

  1. Select the component set.
  2. Identify the conflicting variants.
  3. Compare their property values.
  4. Determine the meaningful difference between them.
  5. Update the appropriate property or value.
  6. Make sure every variant has a unique combination.

46. Avoiding Variant Explosion

Variant explosion occurs when the number of variants grows rapidly because too many properties are combined.

3 Types × 3 Sizes × 4 States × 2 Themes
= 72 theoretical combinations

You do not necessarily need to create all 72 combinations. Create only the combinations that are actually required by the design system.


47. Better Property Architecture

Instead of using one property for multiple unrelated concepts, create separate properties.

Less flexible:

Style:
Primary Large
Primary Small
Secondary Large
Secondary Small

Better:

Type:
Primary
Secondary
 
Size:
Small
Large

Separate properties make the system easier to understand and provide more flexibility.


48. Variants vs Boolean Properties

Requirement Recommended Approach
Different visual state Variant
Different component size Variant
Show or hide an icon Boolean property
Show or hide a badge Boolean property

49. Variants vs Text Properties

If the only difference is text content, creating a separate variant for every text string is usually unnecessary. A Text property is more appropriate for editable content.

Variant:
State = Default
 
Text Property:
Label = Save
Label = Continue
Label = Submit

50. Variants vs Instance Swap

Variants represent predefined versions of a component. Instance Swap properties are useful when a nested component needs to be replaced by another component.

Variant:
State = Hover
 
Instance Swap:
Icon = Search
Icon = Download
Icon = Arrow Right

51. Variants vs Slots

Variants are mainly used to manage different states or types of a component. Slots are designed for flexible content areas where designers need to add, edit, or rearrange content while maintaining the component's underlying design-system structure.

Feature Best Use
Variant States, sizes, types, predictable variations
Boolean Show or hide layers
Text Change text content
Instance Swap Replace nested components
Slot Flexible content areas

52. Variants and Auto Layout

Auto Layout and variants work well together. Auto Layout can control spacing, alignment, padding, and resizing within each variant.

  • Use consistent padding.
  • Maintain consistent spacing.
  • Align icons and text correctly.
  • Allow text to resize where appropriate.
  • Test different content lengths.
  • Maintain consistent dimensions between related states.

53. Responsive Component Variants

Variants can represent meaningful size or layout configurations when the component genuinely requires distinct designs.

Card
├── Compact
├── Standard
└── Large

However, do not create variants simply because a component needs to resize automatically. Auto Layout and responsive sizing may be a better solution.


54. Variants and Interactive Components

Variants can be used to create interactive components. Figma's interactive components allow prototype interactions between variants in the same component set.

Checkbox
├── Checked = False
└── Checked = True
 
Prototype:
Click → Change to Checked

55. Creating Interactive Variant States

  1. Create the component set.
  2. Create the required state variants.
  3. Open the Prototype tab.
  4. Select the interaction trigger.
  5. Connect the source variant to the destination variant.
  6. Use the Change to action.
  7. Configure the trigger and animation.
  8. Test the interaction in prototype mode.

56. Example: Interactive Button

Button Component Set
 
State = Default
State = Hover
State = Pressed
State = Disabled
 
Interaction:
Hover → Change to Hover
Press → Change to Pressed

57. Example: Interactive Checkbox

Checkbox
 
Variant 1:
State = Unchecked
 
Variant 2:
State = Checked
 
Prototype:
On Click
↓
Change to
↓
Checked

58. Component Variants and Design Systems

Variants are particularly valuable in design systems because they turn scattered component versions into an organized and navigable system.

  • Designers can find related components quickly.
  • Teams can use approved variations.
  • Component states are standardized.
  • Design libraries become easier to navigate.
  • Developers can understand intended component states.
  • Design consistency improves across screens and products.

59. Variants and Developer Handoff

Well-named variant properties can communicate design intent to developers.

Button
Type = Primary
Size = Large
State = Disabled

This structure can map naturally to component props in a front-end system.


60. Mapping Figma Variants to Code

Figma:
Button
Type = Primary
Size = Large
State = Disabled
 
Possible code concept:
<Button
  type="primary"
  size="large"
  state="disabled"
/>

Consistent naming between Figma and code can make developer handoff easier and reduce ambiguity.


61. Variants and Component Documentation

Complex component sets should include documentation that explains their purpose, available properties, values, states, and usage rules.

  • Component purpose.
  • Available properties.
  • Available values.
  • State behavior.
  • Content guidelines.
  • Accessibility considerations.
  • Responsive behavior.
  • Usage examples.

62. Documenting a Button Component

Button
 
Type:
Primary - Main action
Secondary - Supporting action
Destructive - Dangerous action
 
Size:
Small - Compact interfaces
Medium - Default usage
Large - Prominent actions
 
State:
Default - Normal state
Hover - Pointer interaction
Pressed - Active interaction
Disabled - Unavailable action

63. Component Variant Descriptions

Figma allows component sets and individual variants to have descriptions. Descriptions can help designers and developers understand the intended use of a component and its variations.

Use descriptions for important usage rules, accessibility guidance, content requirements, or unusual component behavior.


64. Publishing Component Sets to Libraries

Component sets can be published to Figma libraries on supported paid plans. When published, collaborators can access the component set from the Assets panel and configure its available variant properties.

Before publishing, verify naming, property structure, visual consistency, documentation, accessibility, and variant combinations.


65. Variants and Team Collaboration

A well-structured variant system improves collaboration between designers and developers.

  • Designers know which version to use.
  • Developers can understand component states.
  • Teams avoid duplicate components.
  • Design-system maintainers can update components centrally.
  • New team members can understand the library more quickly.

66. Common Mistake: Using Variants for Everything

One of the most common mistakes is creating a variant for every small customization.

Before creating a variant, ask:

  • Is this a meaningful component state?
  • Is this a predictable variation?
  • Could a Boolean property solve it?
  • Could a Text property solve it?
  • Could an Instance Swap solve it?
  • Could a Slot solve it?
  • Could Auto Layout solve it?

67. Common Mistake: Too Many Properties

Creating too many variant properties can make a component difficult to understand. Use only the properties that represent real design-system dimensions.


68. Common Mistake: Poor Property Names

Names such as Property 1, Property 2, and Property 3 do not communicate design intent.

Use meaningful names such as:

Type
Size
State
Theme
Density

69. Common Mistake: Inconsistent Values

Do not mix different naming styles for similar values.

Poor:

Small
medium
LARGE
Big

Better:

Small
Medium
Large

70. Common Mistake: Duplicate Variant Combinations

Every variant should have a unique combination of property values. If two variants have the same values, review whether one of the properties is missing or whether the variants should actually be separate.


71. Common Mistake: Ignoring Content Length

Test variants with realistic content.

Short:
Save
 
Medium:
Save Changes
 
Long:
Save Changes and Continue

This is especially important for buttons, cards, navigation items, and form controls.


72. Common Mistake: Ignoring Accessibility

States such as Focus, Disabled, Error, Selected, and Active should be visually understandable and should meet appropriate accessibility requirements. Do not rely only on subtle color changes to communicate important interaction states.


73. Testing Component Variants

Before sharing a component set with a team, test every important property and combination.

  1. Test every property.
  2. Test every value.
  3. Test important combinations.
  4. Test text lengths.
  5. Test icons.
  6. Test Auto Layout.
  7. Test responsive behavior.
  8. Test interactive states.
  9. Check naming.
  10. Check documentation.

74. Variant Testing Checklist

  • Are all variants visually correct?
  • Are property names understandable?
  • Are values consistent?
  • Are duplicate combinations removed?
  • Is the default variant appropriate?
  • Does Auto Layout work correctly?
  • Does long text work correctly?
  • Do icons align correctly?
  • Do interactive states work correctly?
  • Is the component easy to use?

75. Practical Project: Button Component

Create a complete Button component set.

Button
 
Type:
Primary
Secondary
Destructive
 
Size:
Small
Medium
Large
 
State:
Default
Hover
Pressed
Disabled

Use Auto Layout and consistent spacing across all variants.


76. Practical Project: Input Component

Create an Input component set with different states and sizes.

Input
 
Size:
Small
Medium
Large
 
State:
Default
Focus
Filled
Error
Success
Disabled

Test the component with realistic placeholder and input text.


77. Practical Project: Navigation Item

Navigation Item
 
State:
Default
Hover
Active
Disabled
 
Notification:
On
Off

Consider using a Boolean property for Notification if it only controls whether a notification element is shown or hidden.


78. Practical Project: Card Component

Card
 
Type:
Standard
Featured
 
Size:
Compact
Standard
Large
 
State:
Default
Hover
Disabled

79. Practical Project: Toggle Component

Create a Toggle component using two main variants.

Toggle
├── State = Off
└── State = On

Connect the two variants with a Change to interaction to create an interactive prototype.


80. Practical Project: Badge Component

Badge
 
Type:
Success
Warning
Error
Information
Neutral
 
Size:
Small
Medium
Large

81. Professional Component Variant Workflow

Understand Component Requirements
        ↓
Identify Meaningful Variations
        ↓
Create Base Component
        ↓
Create Related Components
        ↓
Combine as Variants
        ↓
Define Variant Properties
        ↓
Define Variant Values
        ↓
Rename Properties
        ↓
Organize Component Set
        ↓
Set Default Variant
        ↓
Add Other Component Properties
        ↓
Apply Auto Layout
        ↓
Create Interactions
        ↓
Test Variants
        ↓
Document Component
        ↓
Publish to Library When Appropriate
        ↓
Use in Product Designs

82. Advanced Variant Architecture

A scalable component architecture separates meaningful design dimensions rather than combining unrelated changes into one property.

Button
├── Type
│   ├── Primary
│   ├── Secondary
│   └── Destructive
├── Size
│   ├── Small
│   ├── Medium
│   └── Large
├── State
│   ├── Default
│   ├── Hover
│   ├── Pressed
│   └── Disabled
└── Content
    ├── Label
    └── Optional Icon

83. Component Variants and Other Properties

Variants and other component properties can be used together to create flexible but controlled components.

Button
 
Variant:
Type = Primary
Size = Large
State = Default
 
Boolean:
Show Icon = True
 
Text:
Label = Continue
 
Instance Swap:
Icon = Arrow Right

84. Component Variants and Variables

Variables and component variants solve different but complementary design-system problems. Variants can represent component states or structural variations, while variables can help manage reusable design values such as colors, spacing, dimensions, and typography-related tokens.

Using both appropriately can reduce duplication and make a design system easier to scale.


85. Variants and Maintainability

A good variant architecture makes components easier to maintain because related versions are grouped together. When the base component structure changes, designers can manage the corresponding variants as one component family instead of searching through unrelated standalone components.


86. Variants and Design Consistency

Variants encourage designers to use predefined component states and styles rather than recreating them manually. This helps reduce inconsistencies in spacing, typography, colors, borders, radii, and interaction states.


87. Variants and Developer Handoff

Clear variant names make it easier for developers to understand which component state or configuration is intended.

Button
Type = Destructive
Size = Medium
State = Disabled

This can communicate the intended design state much more clearly than an unnamed or manually modified component.


88. Advanced Design-System Strategy

Requirement Recommended Feature
Different component state Variant
Different component size Variant
Different component type Variant
Show or hide an element Boolean property
Change text Text property
Replace nested component Instance Swap
Flexible content region Slot
Automatic spacing and resizing Auto Layout
Reusable design values Variables

89. Interview Questions

1. What are Component Variants in Figma?

Component Variants are different versions of related components grouped into a single component set.

2. What is a component set?

A component set is a container that groups related component variants.

3. What is a variant property?

A variant property defines an attribute by which variants differ, such as Size, Type, or State.

4. What is a variant value?

A variant value is a specific option within a variant property, such as Small, Medium, Large, Default, or Disabled.

5. Why are variants useful?

They organize related components, reduce library clutter, and make predefined component variations easier to select and maintain.

6. What is the difference between a component and a variant?

A component is a reusable design object, while a variant is a specific version of a component within a component set.

7. Can variants be used for interactive prototypes?

Yes. Variants within the same component set can be connected using Change to interactions to create interactive components.

8. What is variant explosion?

Variant explosion is the rapid growth of variants caused by combining too many properties and values.

9. How can variant explosion be prevented?

Use only meaningful combinations and use Boolean, Text, Instance Swap, Slot, Auto Layout, Variables, or other appropriate features when they better match the requirement.

10. Why should variant properties have descriptive names?

Descriptive names make the component easier to understand, configure, document, and use in a design system.


90. Practice Exercise

Create a complete Button component set in Figma.

  1. Create the base button.
  2. Convert it into a component.
  3. Create Primary and Secondary versions.
  4. Create Small, Medium, and Large sizes.
  5. Create Default, Hover, Pressed, and Disabled states.
  6. Combine the components as variants.
  7. Rename the properties to Type, Size, and State.
  8. Organize the variants into a readable grid.
  9. Place the most useful default variant in the top-left.
  10. Create an instance of the component set.
  11. Test the property controls.
  12. Add a Text property for the button label.
  13. Add a Boolean property for an optional icon where appropriate.
  14. Test long labels.
  15. Create interactive prototype transitions.
  16. Document the component.

91. Best Practices

  • Use variants for meaningful and predictable differences.
  • Use descriptive property names.
  • Use consistent value names.
  • Separate different design dimensions into separate properties.
  • Avoid unnecessary combinations.
  • Do not create variants for every text change.
  • Use Boolean properties for simple visibility controls.
  • Use Instance Swap for replaceable nested components.
  • Use Slots for flexible content areas.
  • Use Auto Layout for appropriate spacing and resizing behavior.
  • Test realistic content.
  • Test interactive states.
  • Keep the component set organized.
  • Choose an appropriate default variant.
  • Document complex component behavior.
  • Review the component set before publishing it to a library.

92. Common Mistakes Checklist

  • Creating a variant for every small difference.
  • Creating too many property combinations.
  • Using generic property names.
  • Using inconsistent property values.
  • Creating duplicate variant combinations.
  • Ignoring long content.
  • Ignoring accessibility states.
  • Using variants where Boolean properties are better.
  • Using variants where Text properties are better.
  • Using variants where Instance Swap is better.
  • Using variants as a substitute for flexible content areas.
  • Failing to document complex components.

93. Quick Revision

Term Meaning
Component Reusable design object
Variant Specific version of a component
Component Set Container holding related variants
Variant Property Defines a dimension of variation
Variant Value Specific option of a variant property
Instance Reusable copy of a component or component set
Boolean Property Controls visibility
Text Property Controls editable text
Instance Swap Controls replaceable nested components
Slot Provides flexible content areas
Auto Layout Controls layout, spacing, and resizing
Variable Stores reusable design values

94. Key Takeaways

  • Component Variants are different versions of a reusable component.
  • Related variants are organized inside a component set.
  • Variant properties define how variants differ.
  • Variant values provide the available choices.
  • Common properties include Type, Size, State, Color, and Theme.
  • The top-left variant becomes the default representation of the component set.
  • Every variant should have a unique property-value combination.
  • Do not create every theoretical combination.
  • Use separate properties for separate design dimensions.
  • Use other component properties when variants are not the best solution.
  • Variants can be used to create interactive components.
  • Good naming improves design-system usability.
  • Testing and documentation are important for production component sets.

95. Complete Component Variant Workflow

Understand Requirements
        ↓
Identify Meaningful Variations
        ↓
Create Base Component
        ↓
Create Related Components
        ↓
Combine as Variants
        ↓
Create Variant Properties
        ↓
Define Variant Values
        ↓
Rename Properties Clearly
        ↓
Organize Component Set
        ↓
Choose Default Variant
        ↓
Add Other Component Properties
        ↓
Apply Auto Layout
        ↓
Create Interactive States
        ↓
Test All Important Combinations
        ↓
Document Component
        ↓
Publish to Library When Appropriate
        ↓
Use Variants in Product Screens

96. Conclusion

Component Variants are an important Figma feature for building organized, reusable, and scalable design systems. They allow related component versions to be grouped inside a component set and controlled through meaningful variant properties and values. Variants are especially useful for predictable differences such as states, sizes, types, and styles.

A professional component system should not use variants for every possible customization. Instead, combine variants with Boolean, Text, Instance Swap, Slot, Auto Layout, and Variables according to the type of design requirement. With clear naming, unique combinations, proper organization, testing, documentation, and thoughtful property architecture, Component Variants can make a Figma design system significantly easier to use and maintain.

For detailed Figma training and practical design-system learning, visit JustAcademy Figma Training and Register for Figma Course Demo.

Previous Next
whatsapp