Run a mock round

Middleware are functions with the signature (req, res, next) that run in order and can inspect or modify the request/response, end the cycle, or pass control with next().

• Application-level: app.use(logger).
• Router-level: router.use(auth).
• Error-handling: four arguments (err, req, res, next), registered last.
• Built-in: express.json, express.static.
• Third-party: cors, helmet, morgan.

app.use((req, res, next) => {
  req.startedAt = Date.now();
  next();
});

app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({ error: 'Internal error' });
});

Order matters: authentication and parsing must precede routes that depend on them.

Streams process data in chunks instead of buffering everything, which keeps memory flat for large files and real-time traffic. Four types:

• Readable: source of data (fs.createReadStream, http request).
• Writable: destination (fs.createWriteStream, http response).
• Duplex: both, such as a TCP socket.
• Transform: duplex that modifies data as it passes (zlib.createGzip, a parser).

Pipelines propagate backpressure and errors:

const { pipeline } = require('node:stream/promises');
await pipeline(
  fs.createReadStream('in.csv'),
  new Transform({ transform(c, _e, cb) { cb(null, c.toString().toUpperCase()); } }),
  fs.createWriteStream('out.csv'),
);

Node runs JavaScript on a single thread, so scaling options are:

• Cluster module or a process manager (PM2) to fork one process per core behind a shared port. Good for typical web workloads.
• Worker threads (worker_threads) for CPU-bound jobs within a process, with message passing and SharedArrayBuffer for zero-copy data.
• Horizontal scaling behind a load balancer with stateless processes and externalised sessions (Redis).
• Offload heavy computation to a separate service or a queue.

Also mention: stateless design, health checks, graceful shutdown on SIGTERM, and using the OS or orchestrator (Kubernetes) to manage restarts.

Node uses libuv and phases its loop: timers, pending callbacks, poll, check (setImmediate) and close callbacks, with process.nextTick and promise microtasks draining between phases.

Differences from the browser:

• Node has setImmediate (runs in the check phase) and process.nextTick (runs before promises).
• No DOM or rendering; instead there is filesystem, network, crypto and worker threads.
• Microtasks run after each phase callback, and nextTick has highest priority.

Ordering: nextTick > promise microtasks > setImmediate/timers (relative order of setImmediate and setTimeout(0) can vary).