Observable vs Promise mental model in Angular - Visual Side-by-Side Comparison

Concept Flow - Observable vs Promise mental model

Start

↓

Create Promise

→Promise runs once

↓

Resolve or Reject

↓

Then or Catch

↓

Create Observable

→Observable waits

↓

Subscribe called

↓

Emit values multiple times

↓

Complete or Error

↓

End

This flow shows how a Promise runs once and resolves or rejects, while an Observable waits until subscribed and can emit multiple values over time.

Execution Sample

Angular

const promise = new Promise(res => res('Done'));
promise.then(val => console.log(val));

const observable = new Observable(sub => {
  sub.next('First');
  sub.next('Second');
  sub.complete();
});
observable.subscribe(val => console.log(val));

This code creates a Promise that resolves once and an Observable that emits two values before completing.

Execution Table

Step	Action	Promise State	Observable State	Output
1	Create Promise	Pending	Not created
2	Create Observable	Pending	Waiting for subscription
3	Promise executor runs	Pending	Waiting for subscription
4	Promise then() called	Resolved	Waiting for subscription
5	Promise then() callback runs	Resolved	Waiting for subscription	Console logs: Done
6	Observable subscribe() called	Resolved	Subscribed
7	Observable emits 'First'	Resolved	Emitting	Console logs: First
8	Observable emits 'Second'	Resolved	Emitting	Console logs: Second
9	Observable completes	Resolved	Completed
10	No more emissions	Resolved	Completed

💡 Promise resolves once and Observable completes after emitting multiple values.

Variable Tracker

Variable	Start	After Step 3	After Step 6	After Step 9
promiseState	Pending	Pending	Resolved	Resolved
observableState	Not created	Waiting for subscription	Subscribed	Completed
output			Done	Done, First, Second

Key Moments - 3 Insights

Why does the Promise output only once while the Observable outputs multiple times?

Because the Promise executor runs immediately and resolves once (see execution_table step 4 and 5), while the Observable waits for subscription and can emit many values over time (see steps 6 to 8).

When does the Observable start emitting values?

Only after subscribe() is called (execution_table step 6), unlike the Promise which runs immediately upon creation.

Can a Promise emit multiple values like an Observable?

No, a Promise resolves or rejects once and cannot emit multiple values, as shown by the single output at step 5 in the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, at which step does the Promise resolve?

A Step 3

B Step 6

C Step 8

D Step 9

💡 Hint

Check the Promise State column in execution_table at step 3.

At which step does the Observable start emitting values?

A Step 4

B Step 7

C Step 6

D Step 10

💡 Hint

Look at the Observable State and Output columns in execution_table.

If the Observable did not call complete(), what would happen?

A It would emit values forever

B It would never emit any values

C It would emit values but never signal completion

D It would behave like a Promise

💡 Hint

Refer to the Observable State column and the meaning of complete() in execution_table steps 8 and 9.

Concept Snapshot

Promise:
- Runs immediately
- Resolves or rejects once
- Emits single value

Observable:
- Waits for subscription
- Can emit multiple values over time
- Can complete or error

Use Observable for streams, Promise for single async result.

Full Transcript

This visual execution compares Promise and Observable in Angular. A Promise starts running immediately when created, resolving or rejecting once. The Observable waits until you subscribe, then can emit many values over time before completing. The execution table shows Promise resolving at step 4 and emitting one output at step 5. The Observable starts emitting after subscription at step 6, outputs multiple values at steps 7 and 8, and completes at step 9. Variables track promiseState and observableState changes. Key moments clarify why Promise emits once and Observable can emit many times. The quiz tests understanding of when each runs and emits. This helps beginners see the difference in timing and behavior between Promise and Observable.