Node.js Backend Interview Guide: Event Loop, Streams, APIs & Scaling

console.log('start');
  
  setTimeout(() => console.log('timeout'), 0);
  
  setImmediate(() => console.log('immediate'));
  
  process.nextTick(() => console.log('nextTick'));
  
  Promise.resolve().then(() => console.log('promise'));
  
  console.log('end');
  
  // Deterministic part of the output:
  // start
  // end
  // nextTick   <- microtask queue #1 always drains first
  // promise    <- microtask queue #2 drains next
  // Then either 'timeout' or 'immediate' first (order is NOT guaranteed
  // in the main module), but inside an I/O callback 'immediate' ALWAYS
  // fires before a 0ms 'timeout' because Check runs right after Poll.

const { pipeline, Transform } = require('node:stream');
  const fs = require('node:fs');
  const zlib = require('node:zlib');
  
  class UpperCaseTransform extends Transform {
    _transform(chunk, encoding, callback) {
      // callback() signals "ready for the next chunk" — this is the
      // backpressure contract: never call push() after an unhandled error,
      // and never call callback() more than once per chunk.
      this.push(chunk.toString().toUpperCase());
      callback();
    }
  }
  
  pipeline(
    fs.createReadStream('input.txt'),
    new UpperCaseTransform(),
    zlib.createGzip(),
    fs.createWriteStream('output.txt.gz'),
    (err) => {
      if (err) {
        console.error('Pipeline failed:', err);
        process.exitCode = 1;
      } else {
        console.log('Pipeline succeeded — backpressure handled end-to-end');
      }
    }
  );

const { Worker, isMainThread, parentPort, workerData } = require('node:worker_threads');
  
  function runInWorker(data) {
    return new Promise((resolve, reject) => {
      const worker = new Worker(__filename, { workerData: data });
      worker.once('message', resolve);
      worker.once('error', reject);
      worker.once('exit', (code) => {
        if (code !== 0) reject(new Error('Worker stopped with exit code ' + code));
      });
    });
  }
  
  if (isMainThread) {
    // Main thread stays free to keep serving other requests while this runs.
    runInWorker({ n: 42 }).then((result) => {
      console.log('CPU-bound result computed off the main event loop:', result);
    });
  } else {
    // Runs on a separate V8 isolate — never blocks the main thread's event loop.
    function fib(n) {
      return n < 2 ? n : fib(n - 1) + fib(n - 2);
    }
    parentPort.postMessage(fib(workerData.n));
  }

const server = app.listen(port, () => console.log('Listening on ' + port));
  
  let shuttingDown = false;
  
  async function gracefulShutdown(signal) {
    if (shuttingDown) return;
    shuttingDown = true;
    console.log(signal + ' received: draining connections');
  
    server.close(async () => {
      try {
        await dbPool.end();       // close DB connection pool cleanly
        await redisClient.quit(); // close cache connections cleanly
        console.log('Cleanup complete, exiting');
        process.exit(0);
      } catch (err) {
        console.error('Error during shutdown', err);
        process.exit(1);
      }
    });
  
    // Force-exit if connections don't drain in time (e.g. a stuck socket)
    setTimeout(() => process.exit(1), 10_000).unref();
  }
  
  process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
  process.on('SIGINT', () => gracefulShutdown('SIGINT'));