Overriding instance properties in Figma - Deep Dive

Overview - Overriding instance properties

What is it?

Overriding instance properties in Figma means changing specific settings or styles of a component instance without altering the original master component. This lets you customize parts of a design while keeping the overall structure consistent. For example, you can change the text or color of a button instance without changing the button component itself.

Why it matters

This exists to give designers flexibility and efficiency. Without overriding, every change would require making a new component or editing the master, which is slow and error-prone. Overriding lets teams keep designs consistent but still adapt to different needs quickly, saving time and reducing mistakes.

Where it fits

Before learning this, you should understand what components and instances are in Figma. After mastering overriding, you can explore advanced component variants and design systems that rely heavily on overrides for scalability.

Mental Model

Core Idea

Overriding instance properties lets you customize parts of a component instance while keeping the master component unchanged.

Think of it like...

It's like having a cookie cutter (the master component) and decorating each cookie (instance) differently without changing the cutter itself.

Master Component
  │
  ├─ Instance 1 (overrides: text color, label)
  ├─ Instance 2 (overrides: background color)
  └─ Instance 3 (no overrides)

Overrides only affect the instance, not the master.

Build-Up - 6 Steps

1

Foundation

Understanding Components and Instances

Concept: Learn what components and instances are in Figma and how they relate.

A component is a reusable design element, like a button master. An instance is a copy of that component used in your design. Changes to the master affect all instances unless overridden.

Result

You can create consistent designs by using components and placing instances.

Knowing the difference between master components and instances is key to understanding how overrides work.

2

Foundation

What Are Instance Properties

Concept: Identify which properties of an instance can be changed without affecting the master.

Instance properties include text content, colors, visibility of layers, and some layout settings. These can be changed on an instance to customize it.

Result

You can change text or colors on an instance without editing the master component.

Recognizing which properties are overridable helps you customize designs efficiently.

3

Intermediate

How to Override Instance Properties

Concept: Learn the steps to override properties on an instance in Figma.

Select an instance, then change its text, color, or other properties directly in the design panel. These changes apply only to that instance.

Result

The instance looks different but remains linked to the master component.

Understanding the simple override process empowers quick, flexible design changes.

4

Intermediate

Limits of Overriding Properties

🤔Before reading on: do you think you can override any property of an instance? Commit to your answer.

Concept: Not all properties can be overridden; some are locked by the master component.

Properties like component structure or certain effects cannot be overridden. Trying to change these requires detaching the instance or editing the master.

Result

You learn which changes require more advanced steps.

Knowing override limits prevents frustration and helps plan design changes properly.

5

Advanced

Using Overrides in Component Variants

🤔Before reading on: do you think overrides work the same way with component variants? Commit to your answer.

Concept: Overrides also apply to instances of component variants but interact with variant properties.

Variants group related components with different states. Overrides can customize instances of variants, but variant properties control main differences like size or state.

Result

You can customize variant instances while keeping variant logic intact.

Understanding overrides with variants unlocks powerful, scalable design systems.

6

Expert

Managing Overrides in Large Design Systems

🤔Before reading on: do you think too many overrides can cause problems in design systems? Commit to your answer.

Concept: Excessive or inconsistent overrides can cause maintenance challenges in large projects.

Design systems should balance master component updates and instance overrides. Overriding too much can cause inconsistencies and make updates harder.

Result

Teams learn to use overrides wisely and document their use.

Knowing the tradeoffs of overrides helps maintain design quality and team efficiency.

Under the Hood

Figma stores the master component as the source of truth. Each instance references this master but keeps a separate record of overridden properties. When rendering, Figma applies the master styles first, then applies the instance overrides on top, creating the final appearance.

Why designed this way?

This design allows global updates to components while letting designers customize instances locally. It balances consistency with flexibility, avoiding the need to duplicate components for small changes.

┌───────────────┐
│ Master Component │
│ (Base Styles)  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Instance      │
│ (Overrides)   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Rendered View │
│ (Master +     │
│  Overrides)   │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does changing an instance's text change the master component's text? Commit to yes or no.

Common Belief: Changing text on an instance changes the master component's text too.

Reality: Changing text on an instance only affects that instance, not the master component.

Why it matters: Believing otherwise can cause hesitation to customize instances, reducing design flexibility.

Quick: Can you override the layout structure of an instance without detaching it? Commit to yes or no.

Common Belief: You can change the layout or add new layers inside an instance without detaching it.

Reality: Layout structure and layers are locked by the master component; to change them, you must detach the instance.

Why it matters: Trying to change locked properties wastes time and can break design consistency.

Quick: Do overrides always stay when the master component updates? Commit to yes or no.

Common Belief: Overrides are permanent and never affected by updates to the master component.

Reality: Overrides persist but can be reset or lost if the master component changes conflicting properties.

Why it matters: Misunderstanding this can cause unexpected design changes after master updates.

Quick: Can you override properties on nested components inside an instance? Commit to yes or no.

Common Belief: You cannot override properties of nested components inside an instance.

Reality: You can override certain properties of nested components, but with some limits depending on nesting and master control.

Why it matters: Knowing this allows more precise customization without detaching or duplicating components.

Expert Zone

1

Overrides can be reset individually or all at once, which helps manage changes after master updates.

2

Some overrides can cause performance slowdowns in very large files if overused extensively.

3

Overrides interact with component variants in complex ways, especially when variant properties and overrides conflict.

When NOT to use

Avoid heavy use of overrides when you need consistent, global changes across many instances; instead, update the master component or create new variants. For structural changes, detach instances or create new components.

Production Patterns

Design teams use overrides to customize buttons, icons, and text fields for different screens while maintaining a single source of truth. They combine overrides with variants to handle states like hover or disabled efficiently.

Connections

Object-Oriented Programming (OOP) Inheritance

Overriding instance properties in Figma is similar to overriding methods or properties in OOP subclasses.

Understanding how subclasses override parent class behavior helps grasp how instances override master component properties.

CSS Cascading and Specificity

Overrides in Figma work like CSS rules where more specific styles override general ones.

Knowing CSS cascading helps understand how instance overrides apply on top of master styles.

Version Control Branching

Overrides resemble branches where changes diverge from a main line but can merge or reset.

Seeing overrides as branches clarifies how local changes can coexist with a shared master design.

Common Pitfalls

#1 Trying to change the structure of an instance directly.

Wrong approach:

Selecting an instance and trying to add or remove layers inside it without detaching.

Correct approach:

Detach the instance first, then modify the structure as needed.

Root cause:

Misunderstanding that instance structure is locked by the master component.

#2 Overriding too many properties on many instances without documentation.

Wrong approach:

Changing colors, text, and visibility on hundreds of instances randomly.

Correct approach:

Use variants and master component updates to handle common changes, limit overrides to necessary customizations.

Root cause:

Not planning design system scalability and maintenance.

#3 Assuming overrides are permanent and ignoring master updates.

Wrong approach:

Ignoring master component changes because overrides seem to fix instance appearance.

Correct approach:

Regularly review master updates and reset or adjust overrides as needed.

Root cause:

Lack of understanding of override persistence and master-instance relationship.

Key Takeaways

Overriding instance properties lets you customize parts of a component instance without changing the master component.

Not all properties can be overridden; structure and some effects are locked and require detaching to change.

Overrides apply on top of master styles, allowing flexible but consistent design updates.

Using overrides wisely is essential for scalable and maintainable design systems.

Understanding overrides connects to programming and styling concepts like inheritance and cascading.

Practice

1. What does overriding instance properties in Figma allow you to do?

easy

A. Create a new component from scratch

B. Customize parts of an instance without changing the original component

C. Delete the original component permanently

D. Lock the instance to prevent changes

Solution

1. Step 1: Understand instance and component relationship

   An instance is a copy of a component that inherits its properties.

2. Step 2: Recognize what overriding means

   Overriding lets you change specific properties of an instance without affecting the original component.

3. Final Answer:

   Customize parts of an instance without changing the original component -> Option B

4. Quick Check:

   Overriding = Customize instance only [OK]

Hint: Remember: override changes instance, not original [OK]

Common Mistakes:

• Thinking overriding deletes the original component
• Confusing overriding with creating new components
• Believing overriding locks the instance

2. Which of the following is the correct way to override the text property of an instance in Figma?

easy

A. Double-click the instance and edit the text directly

B. Edit the original component's text

C. Right-click and select 'Detach Instance'

D. Use the 'Lock' option on the instance

Solution

1. Step 1: Identify how to edit instance text

   Double-clicking an instance allows direct editing of its text property.

2. Step 2: Understand difference from editing component

   Editing the original component changes all instances, not just one.

3. Final Answer:

   Double-click the instance and edit the text directly -> Option A

4. Quick Check:

   Edit instance text = Double-click instance [OK]

Hint: Double-click instance to change text quickly [OK]

Common Mistakes:

• Editing the original component instead of the instance
• Detaching instance unnecessarily
• Locking instance instead of editing

3. Given a component with a blue rectangle and text 'Hello', if you override the rectangle color to red in an instance, what will happen when you update the original component's rectangle color to green?

medium

A. The instance rectangle changes to green, text changes to original component's text

B. The instance rectangle changes to green, text changes to 'Hello'

C. The instance rectangle stays red, text remains 'Hello'

D. The instance rectangle stays red, text changes to original component's text

Solution

1. Step 1: Understand property overriding behavior

   Overridden properties in an instance stay as set, ignoring component updates for those properties.

2. Step 2: Apply to rectangle color and text

   Rectangle color overridden to red stays red; text not overridden remains synced with component ('Hello').

3. Final Answer:

   The instance rectangle stays red, text remains 'Hello' -> Option C

4. Quick Check:

   Overridden color stays, non-overridden text syncs [OK]

Hint: Overridden properties ignore component updates [OK]

Common Mistakes:

• Assuming all instance properties update with component
• Thinking overridden text changes automatically
• Confusing overridden and non-overridden properties

4. You tried to override the fill color of an instance, but the color did not change. What is the most likely reason?

medium

A. The fill color is locked in the original component

B. You edited the original component instead of the instance

C. The instance is detached from the component

D. You did not select the fill property in the instance

Solution

1. Step 1: Check if fill color can be overridden

   Some properties like fill color can be locked in the component, preventing overrides.

2. Step 2: Understand why color didn't change

   If locked, changing fill on instance has no effect; you must unlock in component.

3. Final Answer:

   The fill color is locked in the original component -> Option A

4. Quick Check:

   Locked property blocks override [OK]

Hint: Check if property is locked before overriding [OK]

Common Mistakes:

• Editing original component instead of instance
• Assuming detaching fixes override issues
• Forgetting to select the correct property

5. You have a button component with text and background color. You want to create an instance with a different text and a different icon image, but keep the background color linked to the component. How should you override the instance properties?

hard

A. Override all properties including background color to new values

B. Create a new component for the different text and icon

C. Detach the instance and edit all properties freely

D. Override the text and icon image properties only, leave background color unchanged

Solution

1. Step 1: Identify which properties to override

   To keep background color linked, do not override it; override only text and icon image.

2. Step 2: Understand impact of overriding background color

   Overriding background color breaks link to component updates; avoid if you want consistency.

3. Final Answer:

   Override the text and icon image properties only, leave background color unchanged -> Option D

4. Quick Check:

   Override selective properties to keep component link [OK]

Hint: Override only what changes, keep others linked [OK]

Common Mistakes:

• Overriding background color unnecessarily
• Detaching instance losing component benefits
• Creating new component instead of overriding