Node.js Backend Interview 2026: 50+ Event Loop, Async Patterns & Architecture Questions

{`   ┌───────────────────────────┐
┌─>│           timers          │ ← setTimeout, setInterval
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │     pending callbacks     │ ← I/O callbacks deferred
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │       idle, prepare       │ ← internal use only
│  └─────────────┬─────────────┘      ┌───────────────┐
│  ┌─────────────┴─────────────┐      │   incoming:   │
│  │           poll            │<─────┤  connections, │
│  └─────────────┬─────────────┘      │   data, etc.  │
│  ┌─────────────┴─────────────┐      └───────────────┘
│  │           check           │ ← setImmediate
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
└──┤      close callbacks      │ ← socket.on('close')
   └───────────────────────────┘

Between each phase: process.nextTick() and Promise callbacks (microtasks)`}

{`setImmediate(() => console.log('1: setImmediate'));
process.nextTick(() => console.log('2: nextTick'));
Promise.resolve().then(() => console.log('3: Promise'));
console.log('4: sync');

// Output:
// 4: sync
// 2: nextTick  (runs before event loop continues)
// 3: Promise   (microtask queue, after nextTick)
// 1: setImmediate (check phase of event loop)`}

{`// Without streams: loads entire file into memory
const data = fs.readFileSync('huge-file.csv');
processData(data); // Memory spike!

// With streams: processes chunks
const readStream = fs.createReadStream('huge-file.csv');
readStream.pipe(transformStream).pipe(writeStream);
// Memory stays low, starts processing immediately`}

{`// Method 1: try/catch
async function fetchUser(id) {
  try {
    const user = await db.users.findById(id);
    if (!user) throw new NotFoundError('User not found');
    return user;
  } catch (error) {
    logger.error('Failed to fetch user', { id, error });
    throw error; // Re-throw or handle
  }
}

// Method 2: Catch at call site
const user = await fetchUser(id).catch(err => {
  // Handle error
  return null;
});

// Method 3: Wrapper function for cleaner code
async function tryCatch(promise) {
  try {
    const data = await promise;
    return [null, data];
  } catch (error) {
    return [error, null];
  }
}

const [error, user] = await tryCatch(fetchUser(id));
if (error) { /* handle */ }`}

{`// Middleware signature
function middleware(req, res, next) {
  // Do something
  next(); // Pass to next middleware
  // Or: res.send() to end the cycle
  // Or: next(error) to pass to error handler
}

// Execution order
app.use(logger);           // 1. Logs request
app.use(cors());           // 2. Sets CORS headers
app.use(authenticate);     // 3. Validates token
app.use('/api', apiRouter); // 4. Routes

// Error handling middleware (4 params)
app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({ error: 'Internal error' });
});`}

{`// JWT Authentication middleware
const jwt = require('jsonwebtoken');

function authenticate(req, res, next) {
  const authHeader = req.headers.authorization;
  if (!authHeader?.startsWith('Bearer ')) {
    return res.status(401).json({ error: 'No token provided' });
  }

  const token = authHeader.split(' ')[1];
  try {
    const payload = jwt.verify(token, process.env.JWT_SECRET);
    req.user = payload;
    next();
  } catch (error) {
    if (error.name === 'TokenExpiredError') {
      return res.status(401).json({ error: 'Token expired' });
    }
    return res.status(401).json({ error: 'Invalid token' });
  }
}

// Protected route
app.get('/api/profile', authenticate, (req, res) => {
  res.json({ user: req.user });
});`}

{`// PostgreSQL with pg
const { Pool } = require('pg');

const pool = new Pool({
  max: 20,              // Maximum connections
  min: 5,               // Minimum connections
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,
});

// Use pool for queries
async function getUser(id) {
  const client = await pool.connect();
  try {
    const result = await client.query('SELECT * FROM users WHERE id = $1', [id]);
    return result.rows[0];
  } finally {
    client.release(); // Return to pool, don't close!
  }
}`}

{`const { Worker } = require('bullmq');
const Redis = require('ioredis');

const connection = new Redis({ maxRetriesPerRequest: null });

const worker = new Worker('email-queue', async (job) => {
  const { to, subject, body } = job.data;

  try {
    await sendEmail(to, subject, body);
    return { sent: true };
  } catch (error) {
    // Automatic retry with exponential backoff
    throw error;
  }
}, {
  connection,
  concurrency: 10,  // Process 10 jobs in parallel
  limiter: {
    max: 100,       // Max 100 jobs
    duration: 1000, // Per second
  },
});

worker.on('completed', (job, result) => {
  logger.info(\`Job \${job.id} completed\`);
});

worker.on('failed', (job, err) => {
  logger.error(\`Job \${job.id} failed\`, err);
});

// Graceful shutdown
process.on('SIGTERM', async () => {
  await worker.close();
});`}