Run a mock round

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'),
);

For promises and async functions use try/catch and let errors propagate to a central handler:

app.get('/users/:id', asyncHandler(async (req, res) => {
  const user = await repo.find(req.params.id);
  if (!user) throw new NotFoundError();
  res.json(user);
}));

Patterns:

• asyncHandler wraps async routes so rejected promises reach Express error middleware.
• Distinguish operational errors (bad input, network) from programmer errors; only operational errors should be retried/reported to users.
• Attach handlers to streams (.on('error')), EventEmitters and process level 'unhandledRejection'/'uncaughtException' as a last resort, then exit cleanly.
• Use a structured logger and never leak stack traces to clients.

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.

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.