Migrating from observables to signals in Angular - Performance & Optimization

Performance: Migrating from observables to signals

MEDIUM IMPACT

This affects interaction responsiveness and rendering efficiency by changing how Angular tracks and updates reactive data.

Updating UI reactively when data changes

Angular

data = signal(this.service.getInitialData());
this.service.dataStream.subscribe(value => data.set(value));

Signals update only when their value changes and Angular tracks dependencies precisely, reducing unnecessary checks.

📈 Performance Gainreduces change detection cycles to only when needed, improving input responsiveness (INP)

Updating UI reactively when data changes

Angular

this.data$ = this.service.getData();
this.data$.subscribe(value => {
  this.data = value;
  this.cd.detectChanges();
});

Subscribing manually to observables triggers Angular's change detection frequently and can cause redundant updates.

📉 Performance Costtriggers multiple change detection cycles and can block rendering for tens of milliseconds on complex UIs

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Observable with manual subscription	Multiple updates per data change	Multiple reflows if DOM updates frequently	Higher paint cost due to redundant updates	[X] Bad
Signal-based reactive data	Minimal updates only on value change	Single reflow per update	Lower paint cost due to precise updates	[OK] Good

Rendering Pipeline

Signals integrate directly with Angular's reactive system, allowing fine-grained tracking of data dependencies and minimizing full component re-renders.

→Change Detection

→Layout

→Paint

⚠️ BottleneckChange Detection stage is most expensive when using observables with manual subscriptions.

Core Web Vital Affected

INP

This affects interaction responsiveness and rendering efficiency by changing how Angular tracks and updates reactive data.

Optimization Tips

1Use signals to let Angular track reactive data dependencies precisely.

2Avoid manual observable subscriptions that trigger redundant change detection.

3Migrating to signals improves input responsiveness (INP) by reducing overhead.

Performance Quiz - 3 Questions

What is a main performance benefit of using signals over observables in Angular?

A Signals reduce unnecessary change detection cycles.

B Signals increase bundle size significantly.

C Signals block rendering longer than observables.

D Signals require manual subscription management.

DevTools: Performance

How to check: Record a performance profile while interacting with the UI. Look for frequent change detection cycles and long scripting tasks.

What to look for: High scripting time and many change detection events indicate observable subscription overhead; fewer and shorter events indicate efficient signal usage.

Practice

1. What is the main benefit of migrating from Observable to signal() in Angular?

easy

A. More complex code but better performance

B. Signals require manual subscription management

C. Simpler reactive data handling with automatic UI updates

D. Signals do not support reactive updates

Solution

1. Step 1: Understand the purpose of signals

   Signals in Angular provide a simpler way to handle reactive data by automatically updating the UI when the data changes.

2. Step 2: Compare with observables

   Observables require subscriptions and manual management, while signals reduce this complexity and improve performance.

3. Final Answer:

   Simpler reactive data handling with automatic UI updates -> Option C

4. Quick Check:

   Signals simplify reactivity = B [OK]

Hint: Signals auto-update UI, observables need subscriptions [OK]

Common Mistakes:

• Thinking signals require manual subscriptions
• Believing signals increase code complexity
• Assuming signals do not update UI reactively

2. Which of the following is the correct way to create a signal in Angular?

easy

A. const count = createSignal(0);

B. const count = new Signal(0);

C. const count = observable(0);

D. const count = signal(0);

Solution

1. Step 1: Recall Angular signal creation syntax

   Angular uses the signal() function to create reactive signals.

2. Step 2: Check options for correct syntax

   Only const count = signal(0); matches Angular's official syntax.

3. Final Answer:

   const count = signal(0); -> Option D

4. Quick Check:

   Use signal() function = C [OK]

Hint: Use signal() function, not new or createSignal [OK]

Common Mistakes:

• Using new Signal() instead of signal()
• Confusing with createSignal() from other frameworks
• Using observable() which is for RxJS

3. Given this Angular code migrating from observable to signal:

const count = signal(0);

function increment() {
  count.set(count() + 1);
}

increment();
increment();
console.log(count());

What will be logged to the console?

medium

A. 0

B. 2

C. undefined

D. 1

Solution

1. Step 1: Understand signal initial value and increments

   The signal count starts at 0. Each call to increment() adds 1.

2. Step 2: Calculate final value after two increments

   After two calls, count is 0 + 1 + 1 = 2.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   0 + 2 increments = 2 [OK]

Hint: Signals hold value, use .set() and () to get value [OK]

Common Mistakes:

• Forgetting to call count() to get value
• Assuming count is immutable without .set()
• Confusing initial value with updated value

4. What is wrong with this migration from observable to signal?

const count = signal(0);

count.subscribe(value => console.log(value));

count.set(5);

medium

A. Signals do not have a subscribe method

B. You must call count() instead of count.set()

C. Signals require new keyword to create

D. count.set() does not update the signal value

Solution

1. Step 1: Check signal API differences from observables

   Signals do not have a subscribe method; that is an observable feature.

2. Step 2: Identify correct way to react to signal changes

   To react to signals, use computed signals or effects, not subscribe.

3. Final Answer:

   Signals do not have a subscribe method -> Option A

4. Quick Check:

   Signals lack subscribe() = A [OK]

Hint: Signals use effects, not subscribe() [OK]

Common Mistakes:

• Trying to subscribe to signals like observables
• Confusing signal() with observable()
• Using count() incorrectly as a setter

5. You have this observable-based Angular code:

count$ = new BehaviorSubject(0);

increment() {
  this.count$.next(this.count$.value + 1);
}

How would you migrate this to use signals correctly?

hard

A. const count = signal(0);

function increment() {
count.set(count() + 1);
}

B. const count = signal(0);

function increment() {
count = count() + 1;
}

C. const count = new signal(0);

function increment() {
count.set(count() + 1);
}

D. const count = signal(0);

function increment() {
count.next(count() + 1);
}

Solution

1. Step 1: Replace BehaviorSubject with signal()

   Use signal(0) to create a reactive value starting at 0.

2. Step 2: Update increment function to use .set()

   Use count.set(count() + 1) to update the signal's value correctly.

3. Final Answer:

   const count = signal(0); function increment() { count.set(count() + 1); } -> Option A

4. Quick Check:

   Use signal() and .set() to update = A [OK]

Hint: Use .set() to update signals, not assignment or next() [OK]

Common Mistakes:

• Trying to assign directly to signal variable
• Using new keyword with signal()
• Calling next() on a signal