Why this Node.js code logs in the order: A, E, I, G, C, D, F, H

Given code:

console.log('A');
Promise.resolve().then(() => console.log('C'));
queueMicrotask(() => console.log('D'));
(async () => {
  console.log('E');
  await null;
  console.log('F');
})();
process.nextTick(() => console.log('G'));
setImmediate(() => console.log('H'));
console.log('I');

Observed output:

A
E
I
G
C
D
F
H

Key facts about the Node.js event loop

The main script runs to completion (all synchronous logs happen first).
There are multiple queues with priorities:
- process.nextTick queue (highest priority; runs before other microtasks).
- Microtask queue (aka “Promise jobs”), used by Promise.then, queueMicrotask, and async/await continuations.
- Macrotask phases (timers, I/O, check, etc.). setImmediate runs in the “check” phase.
At the end of each turn of the event loop (and between phases), Node drains:
1. All process.nextTick callbacks.
2. Then all regular microtasks (FIFO among Promise.then, queueMicrotask, async/await continuations).
async/await: await always pauses the async function and resumes it in a microtask (even if the awaited value is already resolved). That continuation competes in the same microtask queue as Promise.then and queueMicrotask.

Step-by-step execution

console.log('A') runs synchronously → logs A.
Promise.resolve().then(...) schedules a Promise microtask to log C.
This goes into the microtask queue (Promise jobs) — it’s the first regular microtask scheduled.
queueMicrotask(...) schedules another microtask to log D.
This is queued after the previous Promise.then, so C will run before D.
Immediately-invoked async function starts:
- Logs E synchronously.
- Hits await null. This is equivalent to awaiting Promise.resolve(null). The async function pauses and its continuation (the code that logs F) is queued as a microtask.
- Because the await is encountered after C and D were already scheduled, the continuation for F is placed behind them in the same microtask queue.
process.nextTick(...) schedules G in the special nextTick queue.
This queue is drained before any regular microtasks.
setImmediate(...) schedules H for the “check” phase (a macrotask).
console.log('I') runs synchronously → logs I.
Synchronous work is done. Node drains queues in order:
1. process.nextTick queue → logs G.
2. Microtask queue (FIFO among Promise jobs and queueMicrotask):
  - First the earlier Promise.then → logs C.
  - Then the queueMicrotask → logs D.
  - Then the async/await continuation → logs F.
3. Macrotask (check phase) → setImmediate runs → logs H.

Why this exact order?

A, E, I: synchronous logs run immediately, in order.
G runs next because process.nextTick has higher priority than all other microtasks.
C then D because Promise.then was queued before queueMicrotask.
F after C and D because the async function’s continuation was enqueued later (at the await), behind those microtasks.
H last because setImmediate runs in the check phase, after microtasks have been drained.

Note on environments

This behavior is specific to Node.js. Browsers do not have process.nextTick or setImmediate (without polyfills), and their ordering rules differ for comparable APIs.

Search Courses

Filter by Concepts

Filter by Audience

Active Filters:

No courses found