Node.js backend interviews assess understanding of runtime internals, mastery of asynchronous patterns, and the ability to design performant applications. This guide covers the most frequently asked questions, from fundamentals to advanced production concepts. Recruiters appreciate answers that combine theory with practical examples. For each question, illustrating with code or a concrete use case demonstrates real-world experience. ## Node.js Fundamentals ### Question 1: What is the Event Loop and how does it work? The Event Loop is the core mechanism that allows Node.js to handle asynchronous operations in a non-blocking manner despite running on a single thread. It orchestrates the execution of JavaScript code, callbacks, and events. ```javascript // event-loop-demo.js // Demonstration of Event Loop execution order console.log('1. Script start (synchronous)'); // setTimeout goes to the Timer Queue setTimeout(() => { console.log('5. setTimeout callback (Timer Queue)'); }, 0); // setImmediate goes to the Check Queue setImmediate(() => { console.log('6. setImmediate callback (Check Queue)'); }); // Promise goes to the Microtask Queue (priority) Promise.resolve().then(() => { console.log('3. Promise.then (Microtask Queue)'); }); // process.nextTick has the highest priority process.nextTick(() => { console.log('2. process.nextTick (nextTick Queue)'); }); console.log('4. Script end (synchronous)'); // Output order: 1, 4, 2, 3, 5, 6 ``` The Event Loop follows a precise order when processing queues: first synchronous code, then nextTick, microtasks (Promises), timers, I/O callbacks, setImmediate, and finally close callbacks. ### Question 2: What is the difference between process.nextTick() and setImmediate()? This question evaluates fine-grained understanding of execution priorities in the Event Loop. ```javascript // nextTick-vs-immediate.js // Behavior comparison // process.nextTick executes BEFORE the next Event Loop phase process.nextTick(() => { console.log('nextTick 1'); process.nextTick(() => { console.log('nextTick 2 (nested)'); }); }); // setImmediate executes in the Check phase of the Event Loop setImmediate(() => { console.log('setImmediate 1'); setImmediate(() => { console.log('setImmediate 2 (nested)'); }); }); // Output: nextTick 1, nextTick 2, setImmediate 1, setImmediate 2 ``` `process.nextTick()` is processed immediately after the current operation, before the Event Loop continues. Excessive use can block the Event Loop. `setImmediate()` is more predictable and recommended for deferring execution. Recursive calls to process.nextTick() can starve the Event Loop and prevent I/O processing. Prefer setImmediate() for non-critical operations. ### Question 3: How does Node.js handle errors in asynchronous code? Asynchronous error handling differs fundamentally from synchronous code. Without proper handling, an error can crash the application. ```javascript // error-handling.js // Asynchronous error handling patterns // Pattern 1: Callbacks with error-first convention function readFileCallback(path, callback) { const fs = require('fs'); fs.readFile(path, 'utf8', (err, data) => { if (err) { // Error is ALWAYS the first argument return callback(err, null); } callback(null, data); }); } // Pattern 2: Promises with catch async function readFilePromise(path) { const fs = require('fs').promises; try { const data = await fs.readFile(path, 'utf8'); return data; } catch (err) { // Centralized error handling console.error(`File read error: ${err.message}`); throw err; // Re-throw for propagation } } // Pattern 3: Global handling of unhandled rejections process.on('unhandledRejection', (reason, promise) => { console.error('Unhandled rejection:', reason); // In production: log and graceful shutdown }); // Pattern 4: Handling uncaught exceptions process.on('uncaughtException', (err) => { console.error('Uncaught exception:', err); // CRITICAL: always terminate the process after process.exit(1); }); ``` In production, every Promise must have a `.catch()` or be within a try/catch block. Global handlers serve as a safety net, not the primary solution. ## Asynchronous Programming and Concurrency ### Question 4: Explain the difference between parallelism and concurrency in Node.js Node.js is concurrent but not parallel by default. This distinction is fundamental to understanding performance. ```javascript // concurrency-vs-parallelism.js // CONCURRENCY: multiple tasks progress by alternating (single-thread) async function concurrentTasks() { console.time('concurrent'); // These calls are concurrent, not parallel const results = await Promise.all([ fetch('https://api.example.com/users'), // Non-blocking I/O fetch('https://api.example.com/products'), // Non-blocking I/O fetch('https://api.example.com/orders'), // Non-blocking I/O ]); console.timeEnd('concurrent'); // ~time of the longest request return results; } // PARALLELISM: with Worker Threads for CPU-bound tasks const { Worker, isMainThread, parentPort } = require('worker_threads'); if (isMainThread) { // Main thread delegates CPU-intensive work async function parallelComputation() { console.time('parallel'); const workers = [ createWorker({ start: 0, end: 1000000 }), createWorker({ start: 1000000, end: 2000000 }), createWorker({ start: 2000000, end: 3000000 }), ]; const results = await Promise.all(workers); console.timeEnd('parallel'); return results.reduce((a, b) => a + b, 0); } function createWorker(data) { return new Promise((resolve, reject) => { const worker = new Worker(__filename, { workerData: data }); worker.on('message', resolve); worker.on('error', reject); }); } } else { // Code executed in the Worker Thread const { workerData } = require('worker_threads'); let sum = 0; for (let i = workerData.start; i < workerData.end; i++) { sum += Math.sqrt(i); // CPU-intensive calculation } parentPort.postMessage(sum); } ``` For I/O-bound operations (network, files), native concurrency is sufficient. For CPU-bound tasks (heavy calculations, crypto), Worker Threads enable true parallelism. ### Question 5: How does the Cluster module work? The Cluster module allows creating multiple Node.js processes sharing the same port, thus utilizing all available CPU cores. ```javascript // cluster-example.js const cluster = require('cluster'); const http = require('http'); const numCPUs = require('os').cpus().length; if (cluster.isPrimary) { console.log(`Primary ${process.pid} is running`); console.log(`Forking ${numCPUs} workers...`); // Fork one worker per CPU core for (let i = 0; i < numCPUs; i++) { cluster.fork(); } // Handle crashing workers cluster.on('exit', (worker, code, signal) => { console.log(`Worker ${worker.process.pid} died (${signal || code})`); console.log('Starting a new worker...'); cluster.fork(); // Automatic restart }); // Inter-process communication cluster.on('message', (worker, message) => { console.log(`Message from worker ${worker.id}:`, message); }); } else { // Workers share the TCP port http.createServer((req, res) => { res.writeHead(200); res.end(`Handled by worker ${process.pid}\n`); // Send stats to primary process.send({ type: 'request', pid: process.pid }); }).listen(8000); console.log(`Worker ${process.pid} started`); } ``` Load balancing is handled automatically by the operating system (round-robin on Linux/macOS). In production, PM2 simplifies this management with its built-in cluster mode. ## Streams and Buffers ### Question 6: When should Streams be used instead of classic methods? Streams allow processing data in chunks instead of loading everything into memory. Essential for large files and streaming scenarios. ```javascript // streams-comparison.js const fs = require('fs'); // ❌ BAD: loads entire file into memory async function readEntireFile(path) { const data = await fs.promises.readFile(path); // Blocks if file > RAM return processData(data); } // ✅ GOOD: chunk-based processing with Stream function readWithStream(path) { return new Promise((resolve, reject) => { const chunks = []; const readStream = fs.createReadStream(path, { highWaterMark: 64 * 1024, // 64KB per chunk }); readStream.on('data', (chunk) => { // Progressive processing, constant memory chunks.push(processChunk(chunk)); }); readStream.on('end', () => resolve(chunks)); readStream.on('error', reject); }); } // ✅ BEST: pipeline for chaining transformations const { pipeline } = require('stream/promises'); const zlib = require('zlib'); async function compressFile(input, output) { await pipeline( fs.createReadStream(input), // Source zlib.createGzip(), // Transform fs.createWriteStream(output) // Destination ); // Automatic error handling and backpressure management } ``` Use Streams whenever data size can exceed a few MB, or for real-time processing (uploads, logs, network data). ### Question 7: Explain the concept of backpressure Backpressure occurs when the data producer is faster than the consumer. Without management, memory explodes. ```javascript // backpressure-demo.js const fs = require('fs'); // ❌ Problem: no backpressure handling function badCopy(src, dest) { const readable = fs.createReadStream(src); const writable = fs.createWriteStream(dest); readable.on('data', (chunk) => { // If write() returns false, the internal buffer is full // But here reading continues anyway → memory leak writable.write(chunk); }); } // ✅ Solution: respect the writable signal function goodCopy(src, dest) { const readable = fs.createReadStream(src); const writable = fs.createWriteStream(dest); readable.on('data', (chunk) => { const canContinue = writable.write(chunk); if (!canContinue) { // Pause reading until buffer drains readable.pause(); } }); writable.on('drain', () => { // Buffer drained, resume reading readable.resume(); }); readable.on('end', () => writable.end()); } // ✅ BEST: pipe() handles everything automatically function bestCopy(src, dest) { const readable = fs.createReadStream(src); const writable = fs.createWriteStream(dest); // pipe() handles backpressure natively readable.pipe(writable); } ``` The `pipe()` or `pipeline()` method handles backpressure automatically. For complex cases, implement pause/resume logic manually. ## Performance and Optimization ### Question 8: How to identify and fix memory leaks? Memory leaks are common in Node.js. Knowing how to detect and fix them is essential in production. ```javascript // memory-leak-patterns.js // ❌ Leak 1: closures that retain references function createLeakyHandler() { const hugeData = Buffer.alloc(100 * 1024 * 1024); // 100MB return function handler(req, res) { // hugeData remains in memory as long as handler exists res.end('Hello'); }; } // ✅ Fix: limit the scope function createSafeHandler() { return function handler(req, res) { // Data created and released on each request const data = fetchData(); res.end(data); }; } // ❌ Leak 2: event listeners not cleaned up class LeakyClass { constructor() { // Added on each instantiation, never removed process.on('message', this.handleMessage); } handleMessage(msg) { /* ... */ } } // ✅ Fix: explicit cleanup class SafeClass { constructor() { this.boundHandler = this.handleMessage.bind(this); process.on('message', this.boundHandler); } handleMessage(msg) { /* ... */ } destroy() { // Mandatory cleanup process.removeListener('message', this.boundHandler); } } // Diagnostics with native tools function diagnoseMemory() { const used = process.memoryUsage(); console.log({ heapUsed: `${Math.round(used.heapUsed / 1024 / 1024)}MB`, heapTotal: `${Math.round(used.heapTotal / 1024 / 1024)}MB`, external: `${Math.round(used.external / 1024 / 1024)}MB`, rss: `${Math.round(used.rss / 1024 / 1024)}MB`, }); } // Enable manual garbage collector for testing // node --expose-gc app.js if (global.gc) { global.gc(); diagnoseMemory(); } ``` In production, use tools like `clinic.js`, heap snapshots from Chrome DevTools, or APM solutions (Application Performance Monitoring) like DataDog or New Relic. ### Question 9: How to optimize Node.js API performance? This question evaluates knowledge of optimization techniques at multiple levels. ```javascript // performance-optimization.js // 1. CACHING: reduce expensive calls const NodeCache = require('node-cache'); const cache = new NodeCache({ stdTTL: 300 }); // 5-minute TTL async function getCachedUser(id) { const cacheKey = `user:${id}`; let user = cache.get(cacheKey); if (!user) { user = await db.users.findById(id); cache.set(cacheKey, user); } return user; } // 2. CONNECTION POOLING: reuse DB connections const { Pool } = require('pg'); const pool = new Pool({ max: 20, // Max simultaneous connections idleTimeoutMillis: 30000, connectionTimeoutMillis: 2000, }); // 3. COMPRESSION: reduce response size const compression = require('compression'); app.use(compression({ filter: (req, res) => { // Only compress if > 1KB return compression.filter(req, res); }, threshold: 1024, })); // 4. BATCHING: group operations async function batchInsert(items) { const BATCH_SIZE = 1000; for (let i = 0; i < items.length; i += BATCH_SIZE) { const batch = items.slice(i, i + BATCH_SIZE); await db.items.insertMany(batch); } } // 5. LAZY LOADING: load on demand async function getUserWithPosts(userId, includePosts = false) { const user = await db.users.findById(userId); if (includePosts) { user.posts = await db.posts.findByUserId(userId); } return user; } ``` Optimizations should be guided by profiling. Measure before optimizing to identify actual bottlenecks. 80% of performance issues come from 20% of the code. Use profiling to identify these critical areas before blindly optimizing. ## Security ### Question 10: How to protect a Node.js API against common attacks? Security is a recurring interview topic. Demonstrating knowledge of OWASP vulnerabilities is expected. ```javascript // security-best-practices.js const express = require('express'); const helmet = require('helmet'); const rateLimit = require('express-rate-limit'); const mongoSanitize = require('express-mongo-sanitize'); const xss = require('xss-clean'); const app = express(); // 1. SECURITY HEADERS with Helmet app.use(helmet()); // 2. RATE LIMITING against brute-force attacks const limiter = rateLimit({ windowMs: 15 * 60 * 1000, // 15 minutes max: 100, // 100 requests per IP message: 'Too many requests, please try again later', standardHeaders: true, legacyHeaders: false, }); app.use('/api/', limiter); // 3. SANITIZATION against NoSQL injections app.use(mongoSanitize()); // 4. XSS PROTECTION app.use(xss()); // 5. STRICT INPUT VALIDATION const { body, validationResult } = require('express-validator'); app.post('/api/users', [ body('email').isEmail().normalizeEmail(), body('password').isLength({ min: 8 }).escape(), body('name').trim().escape(), ], (req, res) => { const errors = validationResult(req); if (!errors.isEmpty()) { return res.status(400).json({ errors: errors.array() }); } // Continue processing } ); // 6. SQL INJECTION PROTECTION (with parameters) async function safeQuery(userId) { // ✅ Parameterized query const result = await pool.query( 'SELECT * FROM users WHERE id = $1', [userId] ); return result.rows; } // ❌ NEVER string concatenation async function unsafeQuery(userId) { // Vulnerable to SQL injection const result = await pool.query( `SELECT * FROM users WHERE id = ${userId}` ); } ``` In production, also add: restrictive CORS, mandatory HTTPS, security logging, secrets rotation, and regular dependency audits (`npm audit`). ## Architecture and Design Patterns ### Question 11: Explain the Repository pattern in Node.js The Repository pattern abstracts data access and facilitates testing and maintainability. ```javascript // repository-pattern.js // Abstract interface (for TypeScript, or documentation) class UserRepository { async findById(id) { throw new Error('Not implemented'); } async findByEmail(email) { throw new Error('Not implemented'); } async create(userData) { throw new Error('Not implemented'); } async update(id, userData) { throw new Error('Not implemented'); } async delete(id) { throw new Error('Not implemented'); } } // Concrete implementation with Prisma class PrismaUserRepository extends UserRepository { constructor(prisma) { super(); this.prisma = prisma; } async findById(id) { return this.prisma.user.findUnique({ where: { id } }); } async findByEmail(email) { return this.prisma.user.findUnique({ where: { email } }); } async create(userData) { return this.prisma.user.create({ data: userData }); } async update(id, userData) { return this.prisma.user.update({ where: { id }, data: userData, }); } async delete(id) { return this.prisma.user.delete({ where: { id } }); } } // Implementation for testing class InMemoryUserRepository extends UserRepository { constructor() { super(); this.users = new Map(); this.idCounter = 1; } async findById(id) { return this.users.get(id) || null; } async create(userData) { const user = { id: this.idCounter++, ...userData }; this.users.set(user.id, user); return user; } // ... other methods } // Service using the repository (dependency injection) class UserService { constructor(userRepository) { this.userRepository = userRepository; } async getUser(id) { const user = await this.userRepository.findById(id); if (!user) throw new Error('User not found'); return user; } } ``` This pattern allows changing the persistence implementation without modifying business logic. ### Question 12: How to implement a job queue system? Queues allow deferring heavy tasks and ensuring their reliable execution. ```javascript // job-queue.js const Queue = require('bull'); // Create queue with Redis as backend const emailQueue = new Queue('email', { redis: { host: 'localhost', port: 6379, }, defaultJobOptions: { attempts: 3, // Number of attempts backoff: { type: 'exponential', delay: 2000, // Initial delay between attempts }, removeOnComplete: 100, // Keep last 100 completed jobs }, }); // Producer: add jobs to the queue async function sendWelcomeEmail(userId, email) { await emailQueue.add('welcome', { userId, email, template: 'welcome', }, { priority: 1, // High priority delay: 5000, // 5-second delay }); } // Consumer: process jobs emailQueue.process('welcome', async (job) => { const { userId, email, template } = job.data; // Update progress job.progress(10); const html = await renderTemplate(template, { userId }); job.progress(50); await sendEmail(email, 'Welcome!', html); job.progress(100); return { sent: true, email }; }); // Event handling emailQueue.on('completed', (job, result) => { console.log(`Job ${job.id} completed:`, result); }); emailQueue.on('failed', (job, err) => { console.error(`Job ${job.id} failed:`, err.message); }); // Recurring jobs (cron) emailQueue.add('newsletter', { type: 'weekly' }, { repeat: { cron: '0 9 * * MON', // Every Monday at 9am }, }); ``` Bull with Redis is the most popular solution. For simpler needs, `agenda` or `bee-queue` are lightweight alternatives. ## Advanced Questions ### Question 13: How does the native N-API module work? N-API allows creating native modules in C/C++ with a stable API across Node.js versions. ```cpp // native-module.cpp // Native module for CPU-intensive calculations #include // Synchronous function exposed to JavaScript Napi::Number Fibonacci(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); // Argument validation if (info.Length() < 1 || !info[0].IsNumber()) { Napi::TypeError::New(env, "Number expected") .ThrowAsJavaScriptException(); return Napi::Number::New(env, 0); } int n = info[0].As().Int32Value(); // Iterative Fibonacci calculation long long a = 0, b = 1; for (int i = 0; i < n; i++) { long long temp = a + b; a = b; b = temp; } return Napi::Number::New(env, static_cast(a)); } // Module initialization Napi::Object Init(Napi::Env env, Napi::Object exports) { exports.Set( Napi::String::New(env, "fibonacci"), Napi::Function::New(env, Fibonacci) ); return exports; } NODE_API_MODULE(native_module, Init) ``` ```javascript // Usage from JavaScript const native = require('./build/Release/native_module'); // 10x faster than JavaScript equivalent const result = native.fibonacci(50); ``` Native modules are useful for intensive calculations, integrating existing C/C++ libraries, or accessing system APIs. ### Question 14: Explain the V8 Garbage Collector Understanding the GC helps write code that minimizes pauses and memory consumption. ```javascript // gc-optimization.js // V8 GC uses two spaces: Young and Old Generation // 1. Young Generation: short-lived objects function shortLivedObjects() { for (let i = 0; i < 1000; i++) { const temp = { data: i }; // Allocated then collected quickly } // Minor GC (Scavenge) very fast } // 2. Old Generation: objects that survive multiple GCs const cache = new Map(); // Survives, promoted to Old Generation // ❌ Problematic pattern: many promoted objects function createManyLongLived() { const objects = []; for (let i = 0; i < 100000; i++) { objects.push({ id: i, data: new Array(100).fill(0) }); } return objects; // All promoted to Old Gen = slow major GC } // ✅ Optimized pattern: object reuse class ObjectPool { constructor(factory, size = 100) { this.pool = Array.from({ length: size }, factory); this.available = [...this.pool]; } acquire() { return this.available.pop() || this.pool[0]; } release(obj) { // Reset and return to pool Object.keys(obj).forEach(k => obj[k] = null); this.available.push(obj); } } // GC monitoring const v8 = require('v8'); function getHeapStats() { const stats = v8.getHeapStatistics(); return { totalHeap: `${Math.round(stats.total_heap_size / 1024 / 1024)}MB`, usedHeap: `${Math.round(stats.used_heap_size / 1024 / 1024)}MB`, heapLimit: `${Math.round(stats.heap_size_limit / 1024 / 1024)}MB`, }; } ``` The `--max-old-space-size` flag allows increasing the Old Generation limit for memory-intensive applications. ### Question 15: How to implement graceful shutdown? Graceful shutdown allows completing in-progress requests and properly closing connections before stopping the server. ```javascript // graceful-shutdown.js const http = require('http'); const server = http.createServer((req, res) => { // Simulate a long request setTimeout(() => { res.writeHead(200); res.end('Done'); }, 2000); }); // Tracking active connections let connections = new Set(); server.on('connection', (conn) => { connections.add(conn); conn.on('close', () => connections.delete(conn)); }); // Graceful shutdown function async function shutdown(signal) { console.log(`${signal} received, starting graceful shutdown...`); // 1. Stop accepting new connections server.close(() => { console.log('HTTP server closed'); }); // 2. Close idle connections for (const conn of connections) { conn.end(); } // 3. Close DB connections, queues, etc. await Promise.all([ database.disconnect(), redisClient.quit(), messageQueue.close(), ]); // 4. Safety timeout setTimeout(() => { console.error('Forced shutdown after timeout'); process.exit(1); }, 30000); console.log('Graceful shutdown completed'); process.exit(0); } // Listen for termination signals process.on('SIGTERM', () => shutdown('SIGTERM')); process.on('SIGINT', () => shutdown('SIGINT')); // Start server server.listen(3000, () => { console.log('Server running on port 3000'); }); ``` In production with containers (Docker, Kubernetes), graceful shutdown is critical for zero-downtime deployments. ## Behavioral Questions ### Question 16: Describe a performance problem you solved This question evaluates practical experience. Structure the answer using the STAR format (Situation, Task, Action, Result). **Structured answer example:** ``` Situation: A reporting API was timing out on requests exceeding 100,000 records. Task: Reduce response time from 45s to under 5s. Action: 1. Profiling with clinic.js → identified JSON serialization as bottleneck 2. Implemented streaming with Transform streams 3. Database-side pagination 4. Added Redis caching for frequent queries Result: Response time reduced to 2s, memory usage decreased by 10x. ``` ### Question 17: How do you manage dependencies and their updates? ```javascript // package.json - Versioning best practices { "dependencies": { // ✅ Exact versions for production "express": "4.18.2", // ✅ Caret for compatible minor updates "lodash": "^4.17.21", // ❌ Avoid latest or * // "some-lib": "*" }, "devDependencies": { // Quality tools "npm-check-updates": "^16.0.0" }, "scripts": { // Vulnerability check "audit": "npm audit --audit-level=moderate", // Interactive update "update:check": "ncu", "update:apply": "ncu -u && npm install" }, "engines": { // Specify required Node.js version "node": ">=20.0.0" } } ``` Mention the use of `package-lock.json`, Dependabot or Renovate for automation, and regression testing before each major update. ## Conclusion Node.js backend interviews evaluate both theoretical understanding of internal mechanisms and the ability to solve practical production problems. Mastering the Event Loop, asynchronous patterns, and optimization techniques forms the foundation expected for senior backend developer positions. ### Preparation Checklist - ✅ Understand Event Loop operation and its phases - ✅ Master differences between callbacks, Promises, and async/await - ✅ Know asynchronous error handling patterns - ✅ Know when to use Streams vs classic methods - ✅ Identify and fix memory leaks - ✅ Apply OWASP security best practices - ✅ Implement clustering and graceful shutdown - ✅ Use profiling tools (clinic.js, Chrome DevTools) Technical preparation should be complemented with practical projects. Building a production API, contributing to Node.js open source projects, or solving challenges on platforms like LeetCode helps solidify this knowledge.