Popular Searches
Popular Course Categories
Popular Courses

Text and Instance Swap Properties

Text and Instance Swap Properties

Components & Variants

Text and Instance Swap Properties in Figma

Text Properties and Instance Swap Properties are important Figma Component Property types used to make reusable components flexible, editable, and easier to manage. Text Properties allow designers to change text content directly from an instance, while Instance Swap Properties allow designers to replace a nested component with another suitable component without detaching the main instance.

These properties are especially useful when building professional design systems containing buttons, cards, navigation items, list items, forms, notifications, menus, product cards, dashboards, and other reusable UI components.

JustAcademy Figma Training | Register for Figma Course Demo


1. What are Text Properties?

A Text Property is a Figma Component Property that identifies text content inside a component as editable. When the component is used as an instance, users can change the connected text from the Properties section in the right sidebar or directly on the canvas.

For example, a reusable button can have a Text Property called Label. Each button instance can then display different text such as Login, Submit, Download, or Continue.


2. Simple Definition of Text Property

Text Property = A component property that allows editable text content to be changed in an instance.

Text Property
      ↓
Editable Text Content
      ↓
Component Instance
      ↓
Change Text
      ↓
New Content Appears

3. What are Instance Swap Properties?

An Instance Swap Property is a component property that allows a nested component instance inside a main component to be replaced with another suitable component.

For example, a button may contain a nested icon instance. An Instance Swap Property can allow designers to change the icon from Search to Download, Edit, Delete, Share, or another approved icon without manually restructuring the component.


4. Simple Definition of Instance Swap Property

Instance Swap Property = A component property that allows a nested component instance to be replaced with another component instance.

Instance Swap Property
        ↓
Nested Component
        ↓
Property Control
        ↓
Choose Replacement
        ↓
New Component Appears

5. Text and Instance Swap Properties at a Glance

Feature Text Property Instance Swap Property
Main Purpose Edit text content Replace nested component
Value Type Text/String Component Instance
Example Button Label Button Icon
Control Text field Component selection control
Common Use Labels, titles, descriptions Icons, avatars, actions, illustrations
Design System Benefit Editable content Controlled component replacement

6. Why are Text Properties Important?

Text Properties make reusable components easier to customize. Instead of opening layers and manually selecting text layers, designers can expose only the text that is intended to be changed.

  • Make component text editable.
  • Reduce unnecessary layer overrides.
  • Make component configuration clearer.
  • Improve design-system usability.
  • Allow one component to support many content variations.
  • Make component properties easier to discover.
  • Improve consistency across design files.

7. Why are Instance Swap Properties Important?

Instance Swap Properties provide controlled flexibility. Designers can replace nested components while preserving the main component structure and design-system rules.

  • Allow nested components to be replaced.
  • Reduce repetitive component creation.
  • Support reusable icon systems.
  • Improve component flexibility.
  • Provide controlled replacement options.
  • Support preferred component choices.
  • Reduce unnecessary component duplication.

8. Text Property Example

Consider a reusable button component.

Button
└── Label

Create a Text Property:

Property:
Label
 
Default Value:
Submit

Instances can then use different values.

Button 1 → Submit
Button 2 → Login
Button 3 → Continue
Button 4 → Download

9. Instance Swap Example

Consider a button with an icon.

Button
├── Icon Instance
└── Label

Create an Instance Swap Property:

Property:
Icon
 
Default:
Search Icon

The designer can then replace the icon with another suitable component.

Search
Download
Share
Edit
Delete

10. Text Property and Component Instances

When a Text Property is applied to a main component, instances can edit the exposed text while remaining connected to the main component.

Main Component
      ↓
Text Property
      ↓
Create Instance
      ↓
Edit Text
      ↓
Instance remains connected

11. Instance Swap Property and Component Instances

An Instance Swap Property exposes a nested instance as a controlled replacement point.

Main Component
      ↓
Nested Component
      ↓
Instance Swap Property
      ↓
Create Instance
      ↓
Choose Replacement
      ↓
Nested Component Changes

12. Creating a Text Property

To create a Text Property, select a main component or component set and define which text content should be editable.

  1. Create or select the main component.
  2. Select the text layer that should be editable.
  3. Locate the text content controls in the right sidebar.
  4. Choose the option to apply or create a variable/property.
  5. Create a new Text Property.
  6. Give the property a meaningful name.
  7. Set the default text value.
  8. Create the property.

13. Step-by-Step: Create a Button Text Property

Suppose you are creating a reusable button.

Button
└── Text Layer
  1. Select the main Button component.
  2. Select the text layer inside the button.
  3. Open the text content controls.
  4. Choose Apply variable/property.
  5. Create a Text Property.
  6. Name it Label.
  7. Set the default value to Button.
  8. Create the property.
Property:
Label
 
Default:
Button

14. Editing Text from an Instance

After creating the component instance, the Text Property appears in the component Properties section of the right sidebar.

Button Instance
 
Properties
────────────
Label: Submit

The designer can change the value:

Label: Login

The button text updates while the instance remains connected to the main component.


15. Text Property Example: Navigation Item

Navigation Item
├── Icon
└── Label

Create:

Text Property:
Label

Possible values:

Home
Dashboard
Settings
Profile
Reports

16. Text Property Example: Card

Card
├── Title
├── Description
└── CTA

Possible Text Properties:

Title
Description
CTA Label

This allows one card component to support multiple content scenarios.


17. Text Property Example: Product Card

Product Card
├── Product Name
├── Price
├── Description
└── Button

Possible properties:

Product Name
Price
Description
Button Label

18. Text Property Example: Notification

Notification
├── Title
└── Message

Possible Text Properties:

Title
Message

For example:

Title:
Success
 
Message:
Your profile has been updated.

19. Text Property Example: Form Field

Input Field
├── Label
├── Placeholder
└── Helper Text

Possible Text Properties:

Label
Placeholder
Helper Text

20. Text Property Example: Modal

Modal
├── Title
├── Description
├── Primary Button
└── Secondary Button

Possible Text Properties:

Title
Description
Primary Label
Secondary Label

21. Text Property Example: Empty State

Empty State
├── Title
├── Description
└── Action

Possible Text Properties:

Title
Description
Action Label

22. Naming Text Properties

Text Property names should clearly communicate what content they control.

Recommended Names

  • Label
  • Title
  • Description
  • Message
  • Placeholder
  • Helper Text
  • CTA Label
  • Product Name

Avoid

  • Text 1
  • Content A
  • String
  • Property 1

23. Default Text Values

A default value provides meaningful starting content for the component.

Property:
Label
 
Default:
Continue

Choose a default value that communicates the intended usage of the component.


24. Text Properties and Content Flexibility

Text Properties separate component structure from component content. The designer maintains the component layout while allowing users to change the information displayed inside it.

Structure
   +
Editable Content
   =
Reusable Component

25. Text Properties and Auto Layout

Text Properties work particularly well with Auto Layout. When the text changes, the layout can respond according to the component's Auto Layout settings.

Short Text
[ Save ]
 
Long Text
[ Save Changes ]
 
Auto Layout
     ↓
Adjusts component size

Always test short and long text values to ensure the component remains visually correct.


26. Text Properties and Responsive Components

Responsive components often need different amounts of text. Text Properties make it easier to test different content lengths while maintaining the component structure.

Desktop:
Learn More About Our Services
 
Mobile:
Learn More

27. Text Property and Text Variables

Text Properties can work alongside text variables. Where appropriate, a Text Property can use a string variable as its value, helping connect reusable component content with a variable-based design system.

String Variable:
buttonLabel = "Continue"
 
Text Property:
Label
 
Result:
Continue

28. Important Text Property Consideration

Text Properties are primarily intended to expose editable text content. When text requires special formatting or complex rich-text treatment, designers should test the behavior carefully and make content changes directly on the canvas when necessary.

For example, if a text layer contains special formatting such as list styling, changing the text through the property control may not preserve every formatting detail in the same way as editing the text layer directly.


29. Creating an Instance Swap Property

An Instance Swap Property is created for a nested component instance that should be replaceable.

  1. Create or select the main component.
  2. Select the nested component instance.
  3. Locate the Instance Swap Property controls in the right sidebar.
  4. Create a new Instance Swap Property.
  5. Give the property a meaningful name.
  6. Choose a suitable default component instance.
  7. Add preferred instances when appropriate.
  8. Create the property.

30. Step-by-Step: Create an Icon Swap Property

Consider a button containing an icon instance.

Button
├── Icon Instance
└── Label
  1. Select the Icon Instance inside the main Button component.
  2. Choose the option to create an Instance Swap Property.
  3. Name the property Icon.
  4. Keep a suitable icon as the default value.
  5. Add preferred icon instances if required.
  6. Create the property.

31. What are Preferred Instances?

Preferred Instances allow component creators to curate a list of recommended components that users can select when using an Instance Swap Property.

This is especially useful when a library contains many similar components but only a limited set should be used in a particular component.

Icon Property
      ↓
Preferred Instances
      ↓
Search
Download
Share
Edit
Delete

32. Why Use Preferred Instances?

  • Reduce guesswork.
  • Guide designers toward approved components.
  • Improve design-system consistency.
  • Make component selection faster.
  • Reduce inappropriate component usage.
  • Keep replacement options curated.

33. Instance Swap Property Example: Button Icon

Button
├── Icon
└── Label
 
Instance Swap:
Icon

Preferred instances:

Search
Download
Share
Edit

The designer can select an appropriate icon without manually rebuilding the nested component structure.


34. Instance Swap Property Example: Avatar

Profile Card
├── Avatar Instance
├── Name
└── Role

Create:

Instance Swap:
Avatar

The avatar can then be replaced with another approved avatar component.


35. Instance Swap Property Example: Illustration

Empty State
├── Illustration
├── Title
└── Description

Property:

Illustration

Possible replacement instances:

No Results
No Data
Error
Success
Welcome

36. Instance Swap Property Example: Card Action

Card
├── Content
└── Action Instance

An Instance Swap Property can allow the action component to change while maintaining the card structure.


37. Instance Swap and Design-System Guardrails

Instance Swap Properties provide controlled flexibility. Instead of allowing designers to freely restructure a component, the component creator defines which nested instance can be replaced.

Flexible
    ↓
But Controlled
    ↓
Design-System Consistency

38. Text Property vs Manual Text Override

Manual Text Override Text Property
Designer may need to locate the text layer Text is exposed as a clear property
Less discoverable Easy to find in Properties
Can create uncertainty about editable content Clearly communicates intended editable content
Less centralized Centralized component control

39. Instance Swap vs Manual Instance Swapping

Manual Instance Swap Instance Swap Property
Select nested instance manually Use the exposed property
May require entering component hierarchy Replacement is available through Properties
Less guided Can provide preferred instances
More effort for users Faster component configuration

40. Text Property vs Instance Swap Property

Text Property Instance Swap Property
Changes text Changes nested component
Uses text values Uses component instances
Example: Button Label Example: Button Icon
Controlled through text input Controlled through component selection
Useful for content Useful for interchangeable components

41. Combining Text and Instance Swap Properties

Professional components often use both properties together.

Button
├── Icon Instance
└── Label
 
Properties:
Icon  → Instance Swap
Label → Text Property

This creates a flexible component where both the content and visual icon can be changed.


42. Complete Button Example

Button
├── Icon Instance
└── Label
 
Properties:
Show icon → Boolean
Icon      → Instance Swap
Label     → Text

Possible instance:

Icon:
Download
 
Label:
Download File

43. Combining Text, Instance Swap and Boolean

A highly reusable component can combine multiple property types.

Button
├── Icon
└── Label
 
Properties:
Show icon → Boolean
Icon      → Instance Swap
Label     → Text

This allows designers to control whether the icon appears, which icon is used, and what text is displayed.


44. Combining Text, Instance Swap and Variants

Variants can manage component states while Text and Instance Swap Properties manage content and nested components.

Variants:
State = Default / Hover / Pressed / Disabled
 
Text:
Label
 
Instance Swap:
Icon

This separation keeps the component architecture easier to understand.


45. Text and Instance Swap in a List Item

A list item is an excellent example of multiple component properties working together.

List Item
├── Leading Icon
├── Label
├── Metadata
└── Trailing Component

Properties:

Leading Icon → Instance Swap
Label        → Text
Metadata     → Text
Trailing     → Instance Swap

46. List Item Configuration

Label:
Settings
 
Metadata:
Updated today
 
Leading Icon:
Settings Icon
 
Trailing:
Chevron Icon

The same list item component can be reused across different screens with different content and nested components.


47. Text and Instance Swap in Navigation

Navigation Item
├── Icon
├── Label
└── Badge

Properties:

Icon  → Instance Swap
Label → Text

A Boolean Property can additionally control the visibility of an optional badge.


48. Text and Instance Swap in Product Cards

Product Card
├── Product Image
├── Product Name
├── Price
├── Rating
└── Action

Possible properties:

Product Image → Instance Swap
Product Name  → Text
Price         → Text
Action        → Instance Swap

49. Text and Instance Swap in User Cards

User Card
├── Avatar
├── Name
├── Role
└── Action

Properties:

Avatar → Instance Swap
Name   → Text
Role   → Text
Action → Instance Swap

50. Text and Instance Swap in Notifications

Notification
├── Icon
├── Title
├── Message
└── Action

Properties:

Icon    → Instance Swap
Title   → Text
Message → Text
Action  → Instance Swap

51. Text and Instance Swap in Forms

Form Field
├── Label
├── Input
├── Status Icon
└── Helper Text

Possible properties:

Label       → Text
Placeholder → Text
Status Icon → Instance Swap
Helper Text → Text

52. Text and Instance Swap in Modals

Modal
├── Icon
├── Title
├── Description
├── Primary Action
└── Secondary Action

Possible properties:

Icon            → Instance Swap
Title           → Text
Description     → Text
Primary Action  → Instance Swap
Secondary Action → Instance Swap

53. Text and Instance Swap in Empty States

Empty State
├── Illustration
├── Title
├── Description
└── Action

Properties:

Illustration → Instance Swap
Title        → Text
Description  → Text
Action       → Instance Swap

54. Text and Instance Swap in Alerts

Alert
├── Icon
├── Title
├── Message
└── Action

Properties:

Icon    → Instance Swap
Title   → Text
Message → Text
Action  → Instance Swap

55. Text Property Naming Best Practices

  • Use meaningful names.
  • Keep names short and clear.
  • Use consistent naming across components.
  • Describe the purpose of the text.
  • Avoid generic names such as Text 1 or Text 2.
Good:
Title
Description
Label
Placeholder
CTA Label
 
Avoid:
Text 1
Text 2
Content A
String

56. Instance Swap Naming Best Practices

  • Name the property according to the role of the nested component.
  • Use names such as Icon, Avatar, Illustration, Action, Leading Item, or Trailing Item.
  • Avoid technical names that users may not understand.
  • Use consistent terminology throughout the design system.

57. Choosing Preferred Instances

Preferred Instances should represent components that are appropriate for the context.

Property:
Icon
 
Preferred:
Search
Download
Share
Edit

Do not add every available component if only a small curated group is appropriate.


58. Text Properties and Design-System Consistency

Text Properties help designers reuse a consistent component structure while changing only the content. This prevents users from creating separate components simply because the text is different.

One Component
      ↓
Many Text Values
      ↓
Consistent Structure

59. Instance Swap and Design-System Consistency

Instance Swap Properties help designers replace nested components while preserving the intended component structure. This makes them particularly useful for icons, avatars, illustrations, actions, and other interchangeable assets.


60. Text and Instance Swap with Auto Layout

Both property types work effectively with Auto Layout when the component is structured correctly.

Text Changes
     ↓
Content Width Changes
     ↓
Auto Layout Adjusts
 
Instance Changes
     ↓
Nested Component Changes
     ↓
Layout Responds

Always test different text lengths and replacement components.


61. Text and Instance Swap with Variants

Variants and component properties have different responsibilities.

Feature Best Use
Variant Distinct states, sizes, styles, or structural variations
Text Property Editable content
Instance Swap Replaceable nested components
Boolean Property Show or hide optional layers

62. Text and Instance Swap with Boolean

These properties can work together in a single component.

Button
├── Icon
└── Label
 
Properties:
Show icon → Boolean
Icon      → Instance Swap
Label     → Text

This gives designers three useful controls without requiring multiple duplicate components.


63. Text Property Workflow

Select Main Component
        ↓
Select Text Layer
        ↓
Create Text Property
        ↓
Name Property
        ↓
Set Default Value
        ↓
Create Instance
        ↓
Edit Text
        ↓
Test Content Length
        ↓
Reuse Component

64. Instance Swap Workflow

Select Main Component
        ↓
Select Nested Instance
        ↓
Create Instance Swap Property
        ↓
Name Property
        ↓
Set Default Instance
        ↓
Add Preferred Instances
        ↓
Create Instance
        ↓
Choose Replacement
        ↓
Test Layout
        ↓
Reuse Component

65. Combined Professional Workflow

Create Component
       ↓
Identify Editable Text
       ↓
Identify Replaceable Components
       ↓
Create Text Properties
       ↓
Create Instance Swap Properties
       ↓
Add Preferred Instances
       ↓
Configure Auto Layout
       ↓
Create Component Instance
       ↓
Test Text Changes
       ↓
Test Component Swaps
       ↓
Check Responsive Behavior
       ↓
Document Component
       ↓
Publish to Design System

66. Common Mistake: Making Every Text Layer Editable

Not every text layer needs to be exposed as a Text Property. Decorative or fixed text can remain part of the component structure.

Fixed:
"Success"
 
Editable:
"Your payment was completed successfully."

Expose only the content that users are expected to change.


67. Common Mistake: Poor Text Property Names

A property called Text 1 does not tell the user what it controls.

Bad:
Text 1
Text 2
 
Better:
Title
Description
Button Label

68. Common Mistake: Using Instance Swap for Text

Instance Swap should not be used simply because content changes. If the requirement is only to change text, use a Text Property.

Change words
→ Text Property
 
Change component
→ Instance Swap Property

69. Common Mistake: Using Text Property for Component Replacement

A Text Property cannot replace a nested icon, avatar, illustration, or action component. Use Instance Swap for interchangeable component instances.


70. Common Mistake: Adding Too Many Preferred Instances

Preferred Instances should be curated. Adding every available component can make the replacement menu difficult to use.


71. Common Mistake: Ignoring Long Text

Always test Text Properties with short, medium, and long content.

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

Check wrapping, resizing, alignment, and Auto Layout behavior.


72. Common Mistake: Ignoring Replacement Dimensions

Different nested components may have different dimensions. When using Instance Swap, test replacement components to ensure that the layout remains correct.


73. Common Mistake: Using Instance Swap Instead of Variants

If the requirement is to represent distinct component states such as Default, Hover, Pressed, or Disabled, Variants are generally more appropriate.

Different State
→ Variant
 
Different Nested Component
→ Instance Swap

74. Text Properties and Developer Handoff

Text Properties provide a clear indication of which content is intended to be configurable. This can help designers and developers understand the reusable component structure.

Component:
Button
 
Label:
Editable
 
Icon:
Swappable

75. Instance Swap and Developer Handoff

Instance Swap Properties communicate that a nested component is intentionally replaceable. This can make design-system documentation easier to understand.

Icon:
Swap allowed
 
Preferred:
Search
Download
Share

76. Text and Instance Swap in Design Libraries

When reusable components are published as part of a shared library, clearly defined Text and Instance Swap Properties make components easier for other designers to configure correctly.


77. Component Documentation

Complex components should have documentation explaining which properties can be changed and how they should be used.

Button
 
Label:
Change to match the action.
 
Icon:
Choose an approved icon.
 
State:
Use variants for interaction states.

78. Accessibility Considerations for Text Properties

Editable text should remain meaningful and accessible in the final product.

  • Use descriptive labels.
  • Avoid ambiguous button text.
  • Test long text values.
  • Maintain sufficient contrast.
  • Do not remove important information simply to fit a layout.
  • Consider the final product's accessibility requirements.

79. Accessibility Considerations for Instance Swap

When swapping icons or other visual components, ensure that the replacement component is appropriate for the intended meaning and accessibility requirements.

  • Use semantically appropriate icons.
  • Do not swap icons only because they look attractive.
  • Maintain consistent meaning.
  • Check labels and accessible names in the final implementation.

80. Text and Instance Swap Cheat Sheet

Requirement Use
Change button text Text Property
Change card title Text Property
Change description Text Property
Change icon Instance Swap Property
Change avatar Instance Swap Property
Change illustration Instance Swap Property
Show or hide an element Boolean Property
Change button state Variant Property

81. Practical Project: Flexible Button

Create a button that supports editable text and replaceable icons.

Button
├── Icon Instance
└── Label

Properties:

Show icon → Boolean
Icon      → Instance Swap
Label     → Text

Example:

Show icon = True
Icon = Download
Label = Download File

82. Practical Project: Flexible List Item

Create a list item with editable label and metadata and replaceable leading and trailing components.

List Item
├── Leading Instance
├── Label
├── Metadata
└── Trailing Instance

Properties:

Leading  → Instance Swap
Label    → Text
Metadata → Text
Trailing → Instance Swap

83. Practical Project: Product Card

Product Card
├── Product Image
├── Product Name
├── Price
├── Rating
└── Action

Properties:

Image        → Instance Swap
Product Name → Text
Price        → Text
Action       → Instance Swap

84. Practical Project: User Profile Card

User Card
├── Avatar
├── Name
├── Role
└── Action

Properties:

Avatar → Instance Swap
Name   → Text
Role   → Text
Action → Instance Swap

85. Practical Project: Notification Component

Notification
├── Icon
├── Title
├── Message
└── Action

Properties:

Icon    → Instance Swap
Title   → Text
Message → Text
Action  → Instance Swap

86. Testing Text Properties

Test Expected Result
Change short text Text updates correctly
Change medium text Layout remains correct
Change long text Wrapping and resizing work correctly
Reset text Default value returns correctly
Use multiple instances Each instance can have appropriate content
Check Auto Layout Spacing and alignment remain correct

87. Testing Instance Swap Properties

Test Expected Result
Swap default component Replacement appears correctly
Choose preferred component Selected component replaces original
Swap multiple times Each replacement works correctly
Check component dimensions Layout remains correct
Check Auto Layout Spacing adjusts correctly
Check instance connection Main component relationship remains intact

88. Combined Testing Checklist

  • Text Property has a meaningful name.
  • Default text value is appropriate.
  • Short text has been tested.
  • Long text has been tested.
  • Auto Layout has been tested.
  • Instance Swap Property has a meaningful name.
  • Default nested instance is correct.
  • Preferred instances are relevant.
  • Replacement components fit the intended layout.
  • Component remains easy to use.

89. Professional Component Architecture

Component
│
├── Content
│   ├── Title → Text
│   └── Description → Text
│
├── Visuals
│   ├── Icon → Instance Swap
│   └── Avatar → Instance Swap
│
├── Optional Elements
│   └── Badge → Boolean
│
└── States
    └── Default / Hover / Pressed / Disabled → Variants

This architecture separates content, interchangeable components, optional elements, and component states.


90. Interview Questions

Q1. What is a Text Property in Figma?

A Text Property is a component property that allows designated text content inside a component to be edited through an instance.

Q2. What is an Instance Swap Property?

An Instance Swap Property allows a nested component instance to be replaced with another suitable component instance.

Q3. Where do Text Properties appear?

They appear as editable text controls in the component Properties section of the right sidebar when working with an instance.

Q4. Where do Instance Swap Properties appear?

They appear as component-selection controls in the component Properties section of the right sidebar.

Q5. What is a common use of a Text Property?

A common use is exposing a button label, card title, description, placeholder, or notification message for editing.

Q6. What is a common use of an Instance Swap Property?

A common use is allowing an icon, avatar, illustration, or nested action component to be replaced.

Q7. What are Preferred Instances?

Preferred Instances are curated component choices that help users quickly select appropriate replacements for an Instance Swap Property.

Q8. Can Text and Instance Swap Properties be used together?

Yes. A component can use Text Properties for editable content and Instance Swap Properties for replaceable nested components.

Q9. What is the difference between Text Property and Variant?

Text Property changes content, while Variants represent distinct component variations or states.

Q10. What is the difference between Instance Swap and Boolean?

Instance Swap replaces a nested component, while Boolean controls whether an associated layer is visible or hidden.


91. Quick Revision

Text Property
      ↓
Editable Text
      ↓
Title / Label / Description
      ↓
Flexible Content
 
Instance Swap Property
      ↓
Replace Nested Component
      ↓
Icon / Avatar / Illustration
      ↓
Controlled Flexibility

92. Key Takeaways

  • Text Properties make selected text content editable.
  • Instance Swap Properties make nested component instances replaceable.
  • Text Properties are useful for labels, titles, descriptions, and messages.
  • Instance Swap Properties are useful for icons, avatars, illustrations, and actions.
  • Preferred Instances can provide curated replacement choices.
  • Both properties appear as component controls when working with instances.
  • Text Properties should have meaningful default values.
  • Instance Swap Properties should use appropriate default and preferred components.
  • Both properties work well with Auto Layout.
  • Text and Instance Swap Properties can be combined with Boolean and Variant Properties.

93. Complete Example: Design-System Button

Button
├── Icon Instance
└── Label
 
Properties:
 
Show icon
→ Boolean
 
Icon
→ Instance Swap
 
Label
→ Text
 
State
→ Variant

Example instance:

State:
Default
 
Show icon:
True
 
Icon:
Download
 
Label:
Download File

Another instance can use:

State:
Default
 
Show icon:
True
 
Icon:
Share
 
Label:
Share File

The same reusable component supports different content, icons, and states while maintaining the underlying design-system structure.


94. Text and Instance Swap Decision Guide

Question Recommended Property
Does the user need to change words? Text Property
Does the user need to replace an icon? Instance Swap Property
Does the user need to replace an avatar? Instance Swap Property
Does the user need to show or hide an element? Boolean Property
Does the user need a different component state? Variant Property
Does the user need to insert flexible content? Slot Property

95. Final Conclusion

Text Properties and Instance Swap Properties are powerful tools for creating flexible and scalable Figma components. Text Properties allow designers to expose meaningful text content for editing, while Instance Swap Properties allow nested component instances to be replaced without manually restructuring the main component.

Text Properties are ideal for labels, titles, descriptions, messages, placeholders, and other editable content. Instance Swap Properties are ideal for icons, avatars, illustrations, actions, and other interchangeable components. Preferred Instances can further improve usability by providing a curated list of approved replacement options.

When combined with Boolean Properties, Variants, Auto Layout, Variables, and a well-organized design system, Text and Instance Swap Properties help create components that are flexible for users while still maintaining strong design-system consistency and control.

JustAcademy Figma Training | Register for Figma Course Demo

Previous Next
whatsapp