10 Node.js Concepts for Pune Full Stack Devs (2026)

The list

1. 1

   The Event Loop + Non-blocking I/O

   Node.js is single-threaded for JavaScript but offloads I/O to the libuv thread pool. The event loop processes callbacks from completed I/O operations in phases (timers → pending callbacks → idle → poll → check → close). Why non-blocking: a slow database query doesn't freeze the server.

   Why it matters: Asked at ~85% of Pune Node.js rounds. Walk through the phases verbally; bonus: explain when setImmediate fires vs setTimeout(0).

   Best for: Foundation; expected to know cold.

2. 2

   Promises + async/await over callbacks

   Promises represent eventual values (pending → fulfilled or rejected). async/await is sugar over Promises that reads sequentially. Always await Promises in async functions; unawaited Promises cause silent error loss. Use Promise.all() for parallel work, Promise.allSettled() when you want all results regardless of individual failures.

   Why it matters: Asked at ~75% of Pune rounds. Common gotcha: forgetting that forEach + async/await doesn't work as expected (forEach doesn't await).

   Best for: Async patterns; modern idioms.

3. 3

   Streams + Buffers for memory-efficient I/O

   Streams process data piece-by-piece without loading the entire payload into memory. Four types: Readable (file read, HTTP request), Writable (file write, HTTP response), Duplex (sockets), Transform (compression). Buffers represent fixed-size raw bytes; use for binary data + non-UTF8 strings.

   Why it matters: Asked at ~45% of Pune product company rounds. Streams are how Node.js handles large file uploads + downloads without exhausting memory.

   Best for: Memory efficiency + performance signal.

4. 4

   Express middleware + the request pipeline

   Express apps are a chain of middleware functions: req → middleware1 → middleware2 → ... → handler → response. Each middleware can read/modify req + res or call next() to pass control. Order matters. Common middleware: body-parser, cors, helmet, morgan logger, auth.

   Why it matters: Asked at ~70% of Pune MERN rounds. Walk through writing a custom auth middleware as a coding exercise.

   Best for: Express foundations; MERN-specific signal.

5. 5

   Centralised error handling with next(err)

   In Express, passing an error to next(err) routes to error-handling middleware (4-argument signature: (err, req, res, next)). Define one at the end of the chain to catch all errors. Async route handlers need try/catch + next(err) or express-async-errors package to surface async errors.

   Why it matters: Asked at ~55% of Pune rounds. The most-failed Express question is async error handling — sync errors propagate; unhandled async ones crash the process.

   Best for: Production reliability discipline.

6. 6

   Environment-based configuration + dotenv

   Never commit secrets (API keys, DB passwords) to git. Use .env files via dotenv package for dev; cloud secrets manager (AWS Secrets Manager, Azure Key Vault) for prod. Access via process.env.X. Validate required env vars at startup; fail fast if missing.

   Why it matters: Asked at ~40% of Pune rounds. 12-factor app awareness signal.

   Best for: Configuration discipline; production-ready signal.

7. 7

   JWT authentication with refresh tokens

   Access token (short-lived, ~15 min, stored in memory) + Refresh token (long-lived, ~7 days, stored in httpOnly cookie). Server verifies access token on protected routes; client uses refresh token to get a new access token when it expires. Critical: refresh token rotation prevents replay attacks.

   Why it matters: Asked at ~60% of Pune MERN rounds. The dominant fresher auth pattern; mention httpOnly + SameSite + Secure cookie flags for senior-fresher signal.

   Best for: Auth + security foundation.

8. 8

   REST API design with proper status codes + error responses

   200 OK, 201 Created, 204 No Content for success; 400 Bad Request (client error), 401 Unauthorized, 403 Forbidden, 404 Not Found, 409 Conflict, 422 Unprocessable for client mistakes; 500 Internal Server Error, 502/503/504 for server problems. Consistent error response shape: `{ error: { code, message, details } }`.

   Why it matters: Asked at ~65% of Pune rounds. 500-for-everything is the rookie mistake; specific status codes signal API design maturity.

   Best for: API design discipline.

9. 9

   Process management + clustering

   Single Node.js process uses one CPU core. For multi-core: cluster module (built-in) or PM2 (production process manager). PM2 handles restarts on crash, log aggregation, zero-downtime reload. Modern serverless deployments (Lambda, Vercel) sidestep this — they spawn separate function instances per request.

   Why it matters: Asked at ~30% of Pune rounds, mostly product company + DevOps-leaning interviews.

   Best for: Production deployment depth.

10. 10

    Testing with Jest or Vitest + supertest

    Jest (older standard) or Vitest (modern, faster). Test patterns: unit tests on pure functions, integration tests on API routes (use supertest to make HTTP requests without spinning up a real server), mock external services. Coverage threshold (~70-80%) is a common production CI gate.

    Why it matters: Asked at ~40% of Pune rounds, especially product company + senior-fresher tier. Walking through a test pyramid (unit > integration > E2E) signals engineering discipline.

    Best for: Testing rigour; product-company differentiator.