Video Summary - Top 25 Node.js Interview Questions to Ace Your BackEnd Interview | NodeJS Interview

Summary of Key Node.js Interview Topics (Top 25 Questions)

What is Node.js?
- Open-source, cross-platform JavaScript runtime that runs JavaScript outside the browser (server-side).
- Uses a single-threaded, non-blocking, event-driven architecture for scalability and speed.
Node.js vs JavaScript
- JavaScript: a scripting language mainly used in the browser for interactive features.
- Node.js: lets you run JavaScript on the server to build web servers/APIs, handle data requests, and manage many connections efficiently.

How Node.js works
- Requests are placed in an Event Queue.
- The Event Loop (heart of Node.js) processes tasks:
  - Non-blocking I/O tasks are handled directly by the event loop.
  - Blocking I/O (e.g., database queries) is offloaded to the thread pool (managed by libuv), and results return to the event loop.
Why Node.js is single-threaded
- Keeps design simple and avoids complexity like thread conflicts/deadlocks.
- Scalability comes from offloading heavy work to the thread pool, while the main thread stays free.

Single language (JavaScript) for client + server simplifies development.
Non-blocking, event-driven model supports concurrent connections, ideal for real-time apps (chat/live updates).
Mentions productivity and ecosystem via npm, and usage by major companies such as Netflix, LinkedIn, Walmart, Uber, and eBay.

Hello World in Node.js
- Create a simple HTTP server using the http module.
- Run locally and respond with “hello world” on a port (example mentioned: localhost 8080; subtitles also reference port 80).

Synchronous
- Tasks execute sequentially; later tasks wait.
- Can block on slow operations (network/file/database).
Asynchronous
- Tasks can run concurrently without waiting.
- Improves performance and responsiveness in servers and real-time systems.

Uses an event-driven approach + non-blocking I/O:
- The main thread offloads async tasks.
- The event loop handles callbacks when tasks complete.
Tools mentioned:
- callbacks
- promises
- async/await
Example walkthrough included for:
- Callbacks using fs.readFile with an error-first callback.
- Promises (resolve/reject behavior described).
- async/await (awaits promise resolution within an async function).

Event loop definition
- Monitors completed tasks, runs associated callbacks, and keeps the app responsive.
Callback hell (Pyramid of Doom)
- Deeply nested callbacks become hard to read/maintain/debug and are error-prone.
- Avoidance strategies mentioned:
  - Promises chaining with .then() / .catch()
  - async/await for cleaner, “linear-looking” async code
  - Control-flow libraries (example: async.js)
Promises in Node.js
- Promise states: resolved vs rejected.
- Promise has two handlers: resolve and reject.
async/await
- async function returns a promise.
- await pauses within the async function until the promise resolves; rejects throw errors.

package.json
- Considered the “heart” of a Node.js project: metadata such as name/version/description/main/author/license and dependencies.
- Can be created using npm init and helps share the project reliably.
Common built-in modules (top 5 mentioned)
- http (server creation)
- fs (filesystem read/write)
- path (path handling)
- os (operating system info)
- Express (included in the list in the subtitles; technically a framework, not a built-in module)
Middleware
- Functions that process request/response in a chain (bridge between client/server).
- Used for tasks like logging, authentication, error handling.
- Uses next() to pass control; may end with sending a response.
module.exports
- Exports functions/data from one file to another for reusability and modular code using require.
Event-driven programming + EventEmitter
- Reacts to events (user actions, notifications, data availability).
- events module:
  - create an EventEmitter
  - register listeners with on / once
  - trigger with emit

Buffer class
- Handles raw binary data (useful for file operations and streaming).
- Fixed-size memory chunk; created via Buffer.alloc, Buffer.from, etc.
setImmediate vs setTimeout
- setImmediate: runs after the current event loop iteration; higher priority than timers/I/O callbacks.
- setTimeout: runs after a specified delay; lower priority (after certain timers/I/O callbacks).
Stream types (4)
- Readable (read sequentially)
- Writable (write sequentially)
- Duplex (read/write at once, e.g., TCP)
- Transform (read/write while modifying data, e.g., gzip compression)

HTTP module createServer
- http.createServer() sets up a web server to handle incoming requests and send responses.
Express.js vs Node.js
- Node.js: runtime/foundation to run JS and basic server capabilities.
- Express: lightweight framework on top of Node.js to simplify server creation:
  - routing, middleware, request handling
- Express reduces boilerplate compared to manual HTTP handling.
Common libraries mentioned
- express (web APIs/web apps framework)
- mongoose (MongoDB object modeling: schemas/models, validation, middleware, querying/population)
- Subtitles also mention body-parser (for parsing request bodies) and another library referenced via course context, but the subtitles mainly emphasize Express + Mongoose.

Source: Intellipaat (as referenced throughout the subtitles)
Speaker: An Intellipaat instructor/host (not explicitly named in the subtitles)