Node.js Interview Questions

Answer

Node.js enables writing backend code in JavaScript. Non-blocking I/O handles many concurrent connections efficiently. Single-threaded event loop with async operations scales better than traditional threaded models for I/O-bound tasks.

Answer

Node.js is a runtime built on Chrome's V8 JavaScript engine. Runs JavaScript server-side outside browsers. Single-threaded with non-blocking I/O. Perfect for I/O-bound applications like APIs and real-time apps. Ecosystem: Express for web framework, Socket.io for real-time communication, Mongoose for MongoDB, testing with Jest, build tools with Webpack. npm provides 2+ million packages. JavaScript everywhere: same language frontend and backend.

Answer

I created Express server with app.listen 3000. Defined routes: app.get api users callback returning users array. app.post api users callback reading request.body, validating, creating user, returning status 201. Used middleware: express.json parses JSON. Error handling: try-catch in routes, error middleware catches uncaught errors. This demonstrated REST principles with predictable HTTP methods and status codes.

Answer

const express require express; const app express; app.get api hello (request, response) => { response.json { message Hello World } }; app.listen 3000, () => console.log Server running );

Answer

Event loop runs on single thread. Processes call stack first. Then microtasks (Promises). Then macrotasks (setTimeout, I/O). This allows non-blocking operations: async functions pause, returning control to event loop.

Answer

Event loop runs on main thread. Phases: execute call stack synchronous code first, then process microtask queue Promises, then macrotask queue setTimeout, I/O, timers. Microtasks run before next macrotask. Understanding phases prevents timing bugs. Blocking operations block entire event loop. Non-blocking operations like file reads return control to event loop immediately.

Answer

Application was blocking event loop. Profiling showed long-running synchronous operation in request handler. Moved computation to worker thread or broke into smaller async chunks. Event loop now responsive to other requests. Learned: keep handlers short, offload heavy work, avoid blocking operations.

Answer

app.post api users (request, response) => { const user request.body; if not user.name return response.status 400 .json error; response.status 201 .json { id 1, ...user } };

Answer

Callback function passed to async operation. Executed when operation completes. Error-first callbacks: callback error, result. Nested callbacks create callback hell. Promises and async/await are modern alternatives.

Answer

Callbacks are functions executed when async operation completes. Node.js uses error-first callbacks: callback error, result. Reading files, database queries, network requests use callbacks. Nested callbacks creating pyramid structure: error handling becomes complex, code readability suffers. Callback hell demonstrates need for Promises and async/await. Modern code prefers Promises and async/await over callbacks.

Answer

Legacy code had nested callbacks handling file reads and database queries. Converted to async/await: async function, await on operations, try/catch for errors. Code readability improved dramatically. Error handling centralized in try/catch. Sequential operations now look synchronous.

Answer

async function fetchData() { try { const data await fetch url .then res => res.json; return data; } catch error { console.error error; } }

Answer

Promise represents eventual value or error. States: pending, resolved, rejected. .then handles success, .catch handles error. Chaining .then calls avoids callback nesting. Promise.all waits for multiple promises.

Answer

Promises have three states: pending initial, resolved success, rejected error. then handlers success, catch handlers error, finally runs regardless. Chaining thens allows sequential operations. Promise.all waits for all promises, returns array of results, rejects on first error. Promise.race returns first completed promise. Promise.allSettled returns all results with status.

Answer

In production an unhandled error crashes the process, so I handle errors at three layers. Express error middleware catches route errors, logs them with request context, and returns a JSON 500 without the stack trace. Async handlers are wrapped so rejections forward to next(). At process level, process.on('uncaughtException') catches synchronous throws and process.on('unhandledRejection') catches promise rejections — two different events, and Node 15 and later crash on an unhandled rejection by default. Both handlers log and exit so the process manager restarts a clean instance. On SIGTERM I stop accepting connections, let in-flight requests finish, close the database pool, then exit. Monitoring alerts on error rate, not individual errors.

Answer

const loggingMiddleware = (request, response, next) => { console.log request.method, request.url; next; }; app.use loggingMiddleware;

Answer

async function returns Promise. await pauses function, waits for Promise. Code reads synchronously. try/catch handles errors. More readable than .then chains. Still non-blocking internally.

Answer

async keyword makes function return Promise. await pauses function waiting for Promise. Code reads synchronously, executes asynchronously. try block contains await, catch handles rejections. finally runs regardless. Multiple awaits execute sequentially. Using Promise.all awaits multiple promises concurrently. Proper error handling crucial for production reliability.

Answer

I created authentication middleware verifying tokens from headers. Middleware checked validity, rejected with 401 if invalid, added user info to request if valid. Applied middleware to protected routes: app.use path, authMiddleware, handler. This centralized auth logic, protected routes without duplication.

Answer

fetch url .then response => response.json .then data => console.log data .catch error => console.error error ;

Answer

npm installs packages from npm registry. package.json lists dependencies. npm install fetches and installs. Semantic versioning: major.minor.patch. npm scripts automate tasks. Enables code reuse across projects.

Answer

npm is Node.js package manager. package.json defines project metadata, scripts, dependencies, devDependencies. npm install reads package.json, downloads packages from npm registry, creates node_modules folder. Semantic versioning: major.minor.patch. Caret ^ allows minor updates, tilde ~ allows patch updates. package-lock.json locks exact versions for reproducible installs. npm scripts automate tasks like testing and building.

Answer

I profiled slow queries using database tools. Added indexes on frequently queried columns. Avoided N+1 queries: batch operations or join queries instead of looping. Used query caching for frequently accessed data. Selected only needed columns instead of wildcard. Result: queries 10x faster.

Answer

async function getUser userId { try { const result await database.query SELECT * FROM users WHERE id = userId; return result.rows 0 ; } catch error { console.error error; } }

Answer

Middleware: function receiving request, response, next. Executes code, modifies request/response, calls next() to continue chain. Order matters. Common: logging, authentication, parsing, error handling.

Answer

Middleware functions execute in order. Signature: function middleware request, response, next. Receives request object properties, methods, response object methods for sending data. next() calls next middleware. Middleware can modify request/response. Common: express.json parses JSON, express.static serves files, cors handles cross-origin, authentication checks credentials. Error middleware has four parameters error, request, response, next.

Answer

I created connection pool with pg-pool: new Pool connectionString, max 10 connections. Application requested connections, executed queries, released connections. Pool reused connections across requests. This reduced connection overhead. Configured pool size based on load testing.

Answer

app.use (error, request, response, next) => { console.error error; response.status 500 .json { error error.message } };

Answer

REST: GET retrieve, POST create, PUT update, DELETE remove. Routes: app.get path, callback. Status codes: 200 success, 201 created, 404 not found, 500 error. Express handles routing and responses easily.

Answer

REST uses HTTP methods: GET retrieves, POST creates, PUT updates, DELETE removes. Routes define URLs and handlers. Express: app.get path, callback. Status codes: 200 OK, 201 Created, 400 Bad Request, 404 Not Found, 500 Server Error. Request body accessed via request.body after middleware parses. Response sent via response.json, response.send, or response.status. RESTful APIs are stateless, cacheable, and predictable.

Answer

API needed to fetch user, posts, and comments concurrently. I used Promise.all userId, postId => Promise.all fetchUser, fetchPosts, fetchComments. All requests ran in parallel. Result returned array with all data. Much faster than sequential awaits.

Answer

const fs require fs .promises; async function readFile path { try { const content await fs.readFile path utf8; return content; } catch error { console.error error; } }

Answer

Creating connections is expensive. Connection pool maintains ready-to-use connections. Reusing connections reduces overhead. Pool size affects throughput and resource usage. Configure based on application load.

Answer

Database connections are expensive to create. Connection pool maintains ready connections. Applications request from pool, release after use. Pool size affects performance: too small causes waiting, too large wastes resources. Query execution: send SQL or operations to database, receive results. Transactions: group operations, commit all or rollback all. Connection pooling libraries: pg-pool for PostgreSQL, mysql2 for MySQL.

Answer

I used Jest and supertest to test API. Test created request: request app .get api users .expect 200. Mocked database. Verified response structure. Tested error cases: missing fields, invalid input, 404 responses. Continuous integration ran tests on push. 100% coverage on critical paths.

Answer

const fetch require node-fetch; async function fetchAPI { const response await fetch https api.example.com; const data await response.json; return data; }

Answer

try/catch wraps async/await. Error middleware in Express: (error, request, response, next) signature. Unhandled errors crash application. Proper handling: log, respond with status code, continue gracefully.

Answer

try block wraps potentially throwing code. catch block handles exceptions. Error object contains message and stack trace. Error middleware in Express: app.use error, request, response, next signature. Middleware runs if error thrown or passed to next. Logging: save error details for debugging, different levels: info, warn, error. Graceful responses: return status code and error message without crashing application.

Answer

I built Docker image with Node.js runtime, packaged application. Pushed image to registry. Deployed to cloud platform: AWS ECS, Google Cloud Run, or Heroku. Environment variables configured per deployment. Monitoring with application performance monitoring tools. Logs aggregated to central service. Graceful shutdown handled in process.on SIGTERM.

Answer

const Pool require pg .Pool; const pool new Pool max 10 idleTimeoutMillis 30000 ; pool.query SELECT * FROM users (error, result) => result.rows ;