Microtasks vs Macrotasks

Node schedules async work in two queue families - microtasks (Promises, queueMicrotask, process.nextTick) and macrotasks (timers, setImmediate) - and the drain order explains subtle timing bugs.

Recipe

Ordering cheat sheet (simplified):

1. Run call stack to empty
2. Drain ALL process.nextTick callbacks
3. Drain ALL microtasks (Promises, queueMicrotask)
4. Run ONE macrotask (timer, I/O, setImmediate, ...)
5. Repeat from step 2

process.nextTick(() => console.log('nextTick'));
Promise.resolve().then(() => console.log('promise'));
setTimeout(() => console.log('timer'), 0);
// nextTick → promise → timer

When to reach for this:

• Interview-style ordering puzzles in production code
• Debugging "double execution" after await
• Choosing between nextTick, queueMicrotask, and setImmediate
• Preventing I/O starvation from recursive deferral

Working Example

import { setTimeout, setImmediate } from 'node:timers';
 
async function chain(): Promise<void> {
  console.log('A');
  await Promise.resolve();
  console.log('B');
}
 
chain();
Promise.resolve().then(() => console.log('C'));
process.nextTick(() => console.log('D'));
setTimeout(() => console.log('E'), 0);
console.log('F');
// A, F, D, C, B, E (B may interleave with C depending on await timing)

// Dangerous: recursive nextTick starves I/O
function spin(count: number): void {
  if (count <= 0) return;
  process.nextTick(() => spin(count - 1));
}
// spin(1_000_000); // Never do this in production

What this demonstrates:

• Sync code (A, F) runs before any queued async work
• nextTick precedes Promise microtasks
• await splits async functions into microtask continuations
• Recursive nextTick prevents macrotasks (including I/O) from running

Deep Dive

How It Works

• Macrotasks map to libuv phases: timers, I/O callbacks, setImmediate, etc.
• Microtasks are an internal queue processed after each macrotask (and after sync code).
• process.nextTick is technically separate from the Promise microtask queue but runs before it.
• queueMicrotask schedules spec-compliant microtasks - prefer it over nextTick for generic deferral.

Queue Comparison

TypeScript Notes

// Safe deferral - does not preempt Promise queue like nextTick
function defer(fn: () => void): void {
  queueMicrotask(fn);
}
 
// Run after current I/O batch, not before other microtasks
import { setImmediate } from 'node:timers';
function deferMacrotask(fn: () => void): void {
  setImmediate(fn);
}

Gotchas

• Recursive process.nextTick - starves timers and I/O indefinitely. Fix: use setImmediate for batching or a worker.
• Assuming await makes code "parallel" - it only yields microtasks on the same thread. Fix: use workers for CPU parallelism.
• Mixing nextTick with Promise chains for ordering hacks - fragile across Node versions. Fix: restructure with explicit state machines or queues.
• Unhandled rejections in microtasks - crash the process if not caught before the next macrotask. Fix: always try/catch around await in event handlers.
• Logging microtask order in production - order bugs are dev-time issues; prod needs metrics. Fix: fix architecture, do not rely on log ordering.

Alternatives

FAQs

Related

• libuv Phases - where macrotasks come from
• async/await in Node - practical async patterns
• Event Loop Basics - first ordering examples
• Detecting Event-Loop Blockage - starvation symptoms

Stack versions: This page was written for Node.js 24.18.0 (Active LTS), npm 10+, TypeScript 5.6+, Express 5, Fastify 5, and NestJS 11.