
Explore how Node.js executes code through the event loop, detailing the synchronous start, microtask and macro phase processes, and the roles of promises, process.nextTick, setImmediate, and I/O callbacks.
Explain blocking versus non-blocking operations in node.js, noting I/O handling, CPU-bound tasks, and how the event loop uses asynchronous callbacks.
Learn how blocking the event loop harms performance in NodeJS, and how worker threads prevent unresponsiveness by offloading tasks. Identify which synchronous NodeJS APIs—encryption, compression, and file system—can block.
Libuv delegates io and async cpu tasks to the thread pool during the poll phase; tasks are assigned when a worker is free, otherwise queued.
Learn how Node.js cluster mode uses a built-in load balancer to spawn multiple workers on a single port, leveraging CPU cores for faster requests, and how PM2 offers production-grade clustering.
Semantic versioning uses major, minor, and patch numbers to signal changes: major releases bring breaking changes, minor adds features, patches fix bugs, and check changelogs and run tests before deployment.
Learn robust error handling in NodeJS applications by mastering try/catch with promises, finally, and proper rejection handling; implement error handling middleware in Express and NestJS, and emphasize logging and TypeScript.
Explore the four native Node.js streams—writable, readable, duplex, and transform—and see how data is written, read, transformed, and piped in practical examples like uppercase conversion.
High watermark defines a stream’s internal buffer size in bytes; adjust read and write stream values and monitor readable and writable length to manage data flow.
Master streaming data in Node.js by handling range requests, creating a readable stream, and piping it to the response to deliver 206 partial content with range headers.
Explore why the plain pipe API in Node.js lacks automatic error handling and can cause memory leaks; learn how the pipeline API catches errors and safely destroys affected streams.
Explore the main http methods and their top use cases, including get, post, put, patch, delete, head and options, plus connect and trace, with notes on idempotence and request bodies.
Explore which http methods are idempotent or safe, including get, head, options, trace, put, and delete, and why post is not, with patch nuances.
Learn how http status code classes map to client and server responses, with examples of common codes like 200, 201, 204, 206, 301–302, 304, 400–405, 500–503.
Understand how HTTP requests include method, URL, path parameters, query parameters, headers, body, and cookies for session management and identifying resources.
Explore representational state transfer, a language-agnostic, stateless API style using http methods and json, with xml or text options and soap contrasts, with security considerations.
GraphQL is a specification for querying and manipulating data that solves over fetching and under fetching with a single post endpoint, a strict schema, and language-agnostic JSON responses.
Interviews can be quite stressful. For some reason, you often freeze or struggle to verbalise the concepts with which you work on the daily basis. Although you have enough coding and design knowledge, you might not be as efficient presenting this knowledge as using it in your projects.
Preparation is the best type of effort you can put in, to put your best foot forward in an interview setting. Apart from coding skills, you also need to be able to verbalise the concepts you work with and be able to clearly articulate how they work and what problems they address.
This is where this course comes in. I gathered 100+ actual Node.js interview questions either I personally received or my colleagues did. Although I wouldn't do bad answering those in the actual interview, I often left out important details. Especially when asked about intimate knowledge of how Node.js operates and what makes it so good for the web, database related questions and some good practices around working with them and many more. Here's a glimpse of some of the more important topics covered in this course:
Node.js event loop
Cluster mode (+ PM2), Child Process and Worker Threads
NPM dependencies
stubbing, spying and mocking in testing
Buffer & Stream for working with data
pitfalls of streams when working with a lot of data
data streaming in Node.js
designing data contracts and http responses
REST v GraphQL
CommonJS v ES Modules
webserver building blocks - middleware, interceptor, router, controller, service
relational v non-relational databases
database migrations
SQL anti-patterns
multi-stage Dockerfiles
managing tasks in distributed multi-pod microservice
how to mitigate risk of SQL injection
and MUCH more!
This course is meant to prepare you for such questions by going as deep as needed into each concept, understanding the context of questions, understanding the underlying technology used to address the problem asked by the interviewer and providing clear recommendations. In the end, there are no perfect solutions, there are just trade-offs. To find the right solution, you need to understand those trade-offs.
I know I will be using this course to prepare for my Node.js interviews. I also plan on adding new questions from my own interviews and others’. I would love to add yours too!
Another valuable resource is course repository with running code examples for a lot of questions. That’s the playground where theory meets practice. Each example is a standalone recipe on how to use a component or pattern in practice.
I am not saying this course is going to make you a Node.js expert. But I'm also not saying it won't.