Component properties (text, boolean, instance swap) in Figma - Deep Dive

Overview - Component properties (text, boolean, instance swap)

What is it?

Component properties in Figma let you customize parts of a design component without making new copies. Text properties let you change words inside components. Boolean properties let you switch features on or off, like showing or hiding parts. Instance swap properties let you replace one component inside another easily.

Why it matters

Without component properties, designers must create many separate versions of similar elements, which wastes time and causes mistakes. Component properties make designs flexible and consistent, saving hours and reducing errors. This helps teams deliver better products faster and keeps everyone on the same page.

Where it fits

Before learning component properties, you should understand basic components and instances in Figma. After mastering properties, you can explore advanced variants and interactive components to build dynamic, reusable design systems.

Mental Model

Core Idea

Component properties let you change parts of a design component easily, like flipping switches or typing new text, without breaking the main design.

Think of it like...

Think of a component as a toy robot with buttons. Text properties are like changing the robot's name tag. Boolean properties are like turning the robot's lights on or off. Instance swap is like swapping the robot's arm for a different one without building a new robot.

┌─────────────────────────────┐
│        Component            │
│ ┌───────────────┐           │
│ │ Text Property │ ← Change text here
│ └───────────────┘           │
│ ┌───────────────┐           │
│ │ Boolean Prop  │ ← On/Off switch
│ └───────────────┘           │
│ ┌───────────────┐           │
│ │ Instance Swap │ ← Replace part
│ └───────────────┘           │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Basic Components

Concept: Learn what components and instances are in Figma.

A component is a reusable design element, like a button or icon. An instance is a copy of that component you can place in your design. Changes to the main component update all instances automatically.

Result

You can create one button component and use many instances, keeping your design consistent.

Knowing components and instances is key because properties only work on components and their instances.

2

Foundation

Introducing Component Properties

Concept: Component properties let you customize instances without detaching them.

Instead of making separate components for small changes, you add properties like text fields or toggles. This lets you change parts of an instance directly, like editing the label or turning a feature on/off.

Result

You can have one button component with a text property to change the label on each instance.

Properties save time and keep your design system clean by reducing duplicate components.

3

Intermediate

Using Text Properties

🤔Before reading on: do you think text properties let you change any text inside a component or only specific text fields? Commit to your answer.

Concept: Text properties allow specific text layers inside a component to be editable in instances.

You select a text layer inside a component and mark it as a text property. When you use an instance, you can type new text in that spot without detaching the instance.

Result

Each button instance can have a unique label while sharing the same style and structure.

Understanding text properties helps you balance flexibility and consistency in your designs.

4

Intermediate

Applying Boolean Properties

🤔Before reading on: do you think boolean properties can only hide/show layers or can they also change colors? Commit to your answer.

Concept: Boolean properties act like on/off switches to show or hide parts of a component.

You assign a boolean property to a layer or group inside a component. In instances, toggling this property shows or hides that part, like an icon or shadow.

Result

You can create one button component that optionally shows an icon by toggling a boolean property.

Boolean properties let you create versatile components without making many variants.

5

Intermediate

Mastering Instance Swap Properties

Concept: Instance swap properties let you replace nested components inside a parent component.

Inside a component, you place another component as a placeholder. You mark it as an instance swap property. In instances, you can swap that nested component for another compatible one.

Result

A card component can swap its icon or image easily without creating new card components.

Instance swap properties enable modular design systems with flexible building blocks.

6

Advanced

Combining Multiple Property Types

🤔Before reading on: do you think you can use text, boolean, and instance swap properties together in one component? Commit to your answer.

Concept: You can mix text, boolean, and instance swap properties in a single component for rich customization.

For example, a button component can have a text property for the label, a boolean property to show an icon, and an instance swap property to change the icon itself.

Result

One component can serve many design needs, reducing complexity and improving maintainability.

Combining properties unlocks powerful, scalable design systems that adapt to many use cases.

7

Expert

Optimizing Component Properties for Performance

🤔Before reading on: do you think adding many properties always improves design speed or can it sometimes slow things down? Commit to your answer.

Concept: Too many properties or complex nested swaps can slow down Figma and confuse users.

Experts balance the number and type of properties to keep components fast and easy to use. They also document property usage clearly for teams.

Result

Design systems stay efficient and user-friendly even as they grow.

Knowing when and how to limit properties prevents performance issues and user frustration in large projects.

Under the Hood

Figma stores component properties as metadata linked to specific layers or nested components. When you edit an instance, Figma overrides only the property values without detaching the instance. This keeps the connection to the main component intact, allowing updates to flow through while preserving customizations.

Why designed this way?

This design balances flexibility and consistency. Early design tools required detaching instances to customize, breaking links and causing maintenance headaches. Properties let users customize safely without losing the benefits of components. Alternatives like creating many variants were less scalable and harder to manage.

┌───────────────┐
│ Main Component│
│ ┌───────────┐ │
│ │ Text Layer│ │ ← Text Property
│ └───────────┘ │
│ ┌───────────┐ │
│ │ Icon Comp │ │ ← Instance Swap Property
│ └───────────┘ │
│ ┌───────────┐ │
│ │ Shadow    │ │ ← Boolean Property
│ └───────────┘ │
└───────┬───────┘
        │
        ▼
┌───────────────┐
│ Instance      │
│ Text: "Save" │
│ Icon: Icon B  │
│ Shadow: Off   │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think changing text in an instance breaks the link to the main component? Commit to yes or no.

Common Belief: Changing text in an instance detaches it from the main component.

Reality: Text properties let you change text without detaching the instance, keeping the link intact.

Why it matters: Detaching breaks updates from the main component, causing inconsistent designs and extra work.

Quick: Do you think boolean properties can change colors or only show/hide layers? Commit to your answer.

Common Belief: Boolean properties can change colors or styles directly.

Reality: Boolean properties only toggle visibility or presence of layers, not colors or styles.

Why it matters: Misusing boolean properties for style changes leads to confusion and forces unnecessary variants.

Quick: Can instance swap properties replace any layer or only nested components? Commit to your answer.

Common Belief: Instance swap properties can replace any layer inside a component.

Reality: They only work with nested components, not simple layers like shapes or text.

Why it matters: Trying to swap non-component layers causes errors and limits design flexibility.

Quick: Do you think adding many properties always improves component usability? Commit to yes or no.

Common Belief: More properties always make components better and more flexible.

Reality: Too many properties can confuse users and slow down Figma performance.

Why it matters: Overloading components with properties reduces team productivity and increases errors.

Expert Zone

1

Boolean properties can be combined with variants to create complex toggle behaviors without exploding variant counts.

2

Instance swap properties require careful naming and organization of nested components to avoid confusion during swaps.

3

Text properties only work on text layers set to 'Auto Width'; fixed width text layers won't resize properly when text changes.

When NOT to use

Avoid using component properties when your design requires radically different layouts or behaviors; in those cases, use variants or separate components instead. Also, if performance slows down due to many nested swaps, consider simplifying your component structure.

Production Patterns

Design systems often use a base component with text and boolean properties for common UI elements like buttons, combined with instance swaps for icons or images. Teams document property usage in style guides and limit properties per component to keep designs scalable and maintainable.

Connections

Software Feature Flags

Similar pattern of toggling features on or off dynamically.

Understanding boolean properties in design helps grasp how developers use feature flags to enable or disable software features without redeploying code.

Object-Oriented Programming (OOP) - Inheritance and Polymorphism

Component properties act like polymorphic overrides allowing instances to customize behavior while inheriting from a base class.

Knowing component properties deepens understanding of how OOP lets objects share structure but differ in details.

Modular Furniture Design

Instance swap is like swapping parts of modular furniture to change function or style without buying new pieces.

This cross-domain link shows how modularity principles apply both in physical design and digital components.

Common Pitfalls

#1 Trying to edit text inside an instance without setting a text property.

Wrong approach:

Selecting a text layer inside an instance and typing directly without text property setup.

Correct approach:

Set the text layer inside the main component as a text property, then edit text in the instance.

Root cause:

Misunderstanding that only text layers marked as text properties are editable in instances.

#2 Using boolean properties to change colors by toggling colored layers.

Wrong approach:

Creating multiple colored layers and toggling visibility with boolean properties to simulate color changes.

Correct approach:

Use variants or color styles for color changes instead of boolean toggles.

Root cause:

Confusing visibility toggles with style changes, leading to complex and hard-to-maintain components.

#3 Attempting to swap a simple shape layer using instance swap property.

Wrong approach:

Marking a rectangle shape as an instance swap property and trying to replace it with another shape.

Correct approach:

Use nested components for parts you want to swap, then mark those nested components as instance swap properties.

Root cause:

Not realizing instance swap only works with components, not basic layers.

Key Takeaways

Component properties let you customize parts of a design component without detaching or duplicating it.

Text properties make specific text inside components editable in instances, keeping consistency and flexibility.

Boolean properties act as switches to show or hide layers, enabling versatile component states without many variants.

Instance swap properties allow replacing nested components inside a parent component, supporting modular design.

Balancing the number and type of properties is crucial to maintain performance and usability in large design systems.