Topic

Node.js async work & the event loop

Definition

The Node.js event loop coordinates JavaScript callbacks and promise continuations while asynchronous I/O is performed by the operating system or Node worker pool, allowing one process to keep many operations in flight without blocking on each one.

In simpler words

Node can start I/O, work on other requests, and continue when the result is ready — but slow synchronous work still blocks every request sharing that process.

HTTP handlers, database calls, password hashing, and file operations are asynchronous. Understanding await, rejection, and blocking work prevents framework code from hiding runtime-level failures.

Open official example (opens in new tab)

After this you can

Explain what async/await does and does not make asynchronous
Distinguish non-blocking I/O from CPU-heavy synchronous work
Propagate rejected promises to an HTTP error boundary
Avoid fire-and-forget work that loses errors

Promises and async/await

Definition

A Promise represents the eventual fulfillment or rejection of an asynchronous operation; an async function always returns a Promise, and await pauses only that function until the Promise settles.

In simpler words

await makes promise code read in order. It does not freeze Node, but it also does not turn synchronous CPU work into background work.

Returning or awaiting a Promise keeps success and failure connected to the caller.

Independent operations may run concurrently with Promise.all; dependent operations should remain sequential.

Catch an error only when you can add context, recover, or translate it. Otherwise let the framework error boundary handle it.

Keep failures connected to the request

app.get('/notes/:id', async (req, res, next) => {
  try {
    const note = await notes.findById(req.params.id);
    res.json(note);
  } catch (error) {
    next(error);
  }
});

Awaiting the repository call lets the handler pass rejection to Express error middleware. Nest later performs this translation through its request pipeline and exception filters.

Mistake: detached work

// Wrong — rejection is detached from the request
app.post('/notes', (req, res) => {
  notes.save(req.body);
  res.status(201).end();
});

// Right — await before claiming success
app.post('/notes', async (req, res, next) => {
  try {
    const note = await notes.save(req.body);
    res.status(201).json(note);
  } catch (error) {
    next(error);
  }
});

Do not report success before the write has succeeded unless an explicit durable background-job design exists.

Blocking the event loop

Definition

Event-loop blocking occurs when long synchronous JavaScript or synchronous native work prevents Node from starting or completing other callbacks in the same process.

In simpler words

One expensive synchronous task can stall every request handled by that process.

Synchronous file reads, huge JSON transformations, unbounded loops, and inappropriate password-hashing settings can delay unrelated requests.

Prefer asynchronous I/O APIs. For truly CPU-heavy work, use bounded worker threads or a background-job system.

Measure before optimizing: latency, event-loop delay, and CPU profiles identify whether the bottleneck is I/O, the database, or CPU work.

Keep in mind

Return or await every request-scoped Promise.
Do not send a success response before the required write succeeds.
Treat synchronous CPU work as shared latency for every request in the process.

Test

Check your understanding

At least 10 questions — mix of concept, syntax, practical, and logic. Score ≥80% (enforced by the API) to save progress.

Checking your session…

15 questions · concept 5 · syntax 3 · practical 4 · logic 3

1. What does await do inside an async function?

Concept

Blocks the current thread but lets a worker thread keep serving requestsSuspends the function and moves its continuation onto a separate OS threadPauses the function and also halts all pending timers until the promise settlesPauses only that function while other I/O can still progress on the event loop

2. Why must rejected promises be handled in request handlers?

Syntax

Because Node automatically retries a rejected promise until it resolvesBecause an unhandled rejection rolls back the current database transactionBecause a rejected promise blocks the event loop until it is caughtOtherwise failures can become silent and leave clients hanging or unlogged

3. What is dangerous about fire-and-forget Promises in a handler?

Practical

The detached promise keeps the HTTP connection open until it resolvesErrors after res.json may never reach Nest exception filtersNest re-runs the handler each time the background promise settlesThe response is delayed until the fire-and-forget promise completes

4. How can synchronous CPU work hurt Node servers?

Logic

Long sync loops block the event loop so other requests stallSync CPU work spins up extra event loops that compete for the threadSync work is fine because Node runs each request on its own event loopHeavy sync loops only pause I/O callbacks, not other computation

5. Which pattern correctly propagates async errors in Nest?

Concept

Await the promise or return it so exceptions reach filtersCatch the error and call res.status(500).send() manually in the serviceWrap the handler body in a setTimeout so rejections surface laterLog the rejection and return a resolved promise so the request still succeeds

6. What does non-blocking I/O enable?

Practical

True parallel execution of JavaScript across all CPU cores in one processEach incoming request running on its own dedicated OS threadFaster CPU-bound work by splitting loops across the event loopOne process handling many concurrent waiting requests

7. Which statement about Promise.all is correct?

Syntax

It waits for every promise to settle and returns both fulfilled and rejected resultsIt resolves as soon as the first input promise fulfillsIt runs the promises strictly one after another in array orderIt fails fast if any input rejects unless you handle that case

8. When is setImmediate/process.nextTick relevant?

Logic

Scheduling work after the current turn without pretending it is parallel CPUOffloading CPU-heavy work to a background thread so the loop stays freeGuaranteeing a callback runs before any pending I/O regardless of phaseDelaying a callback by a fixed number of milliseconds like setTimeout

9. Which fix for handler returns before DB finishes is right?

Concept

Wrap the repository call in setImmediate so it settles before returningAdd a short setTimeout delay to give the query time to finish firstAwait the repository call before returning the response bodyRemove the async keyword so Nest blocks until the query resolves

10. Why is async makes everything non-blocking false?

Practical

Because await only defers I/O by one event-loop tick before blocking againBecause async functions run synchronously unless you also add a callbackBecause only functions marked both async and deferred are non-blockingAsync functions still run sync code until the first await, and sync CPU still blocks

11. Both endpoints fetch two independent resources. Which is faster and why?

Conceptadvanced

// A
const user = await getUser(id);
const posts = await getPosts(id);
// B
const [user, posts] = await Promise.all([getUser(id), getPosts(id)]);

A, because sequential awaits let Node batch the two queries into one round tripThey are identical because await never blocks other work anywayB is slower because Promise.all runs the two calls on separate threadsB, because Promise.all starts both awaits concurrently instead of waiting for the first

12. This handler makes the whole server unresponsive under load. Why?

Syntaxintermediate

@Get('report')
report() {
  let total = 0;
  for (let i = 0; i < 5e9; i++) total += i;
  return { total };
}

The long synchronous loop blocks the single event-loop thread so no other request can be servedReturning a plain number instead of a Promise stalls the event loopNest runs each request on its own thread, so this cannot happenThe tight loop allocates so much memory it triggers constant GC pauses

13. What risk does the un-awaited slowAudit() create?

Practicaladvanced

@Get()
list() {
  this.svc.slowAudit(); // returns a Promise, not awaited
  return this.svc.list();
}

It blocks list() from returning until slowAudit() resolvesIf it rejects, the error escapes the request and may become an unhandled rejectionNest automatically awaits every promise a handler calls internallyIts result silently overwrites the list() response body

14. While await slow() is pending, what can the process do?

Logicintermediate

async function handler() {
  const a = await slow();
  return a;
}

Nothing else, because the process is parked until slow() settlesOnly fire already-scheduled timers, but not accept new requestsServe other requests, because await yields the function without blocking the loopContinue running the code after the await line before slow() resolves

15. fail() rejects in this Promise.all. What happens?

Conceptadvanced

const [a, b] = await Promise.all([ok(), fail()]);

a is assigned from ok() and b is left undefined after the rejectionPromise.all rejects immediately; the whole await throws and a/b are never assignedBoth destructured values are undefined but no error is thrownok() is cancelled the moment fail() rejects, so neither promise runs

Checking your session…