Interview Q&A

sync function connect() {

const uri = 'mongodb://localhost:27017/mydatabase';
const client = new MongoClient(uri);

try {

wait client.connect();

console.log('Connected to MongoDB');

const db = client.db('mydatabase');

// Use `db` to query collections

} catch (err) {

console.error(err);

} finally {

wait client.close();

}
}

connect();

time per process. Clustering allows you to create multiple Node.js processes (workers)

that share the same server port. This way, your app can utilize multiple CPU cores and

handle more requests concurrently.

📌 Example: Using the built-in cluster module, you can fork multiple workers.

Node.js is an open-source, cross-platform runtime environment that allows you to run

JavaScript on the server side. It’s built on the V8 JavaScript engine developed by Google

(the same one used in Chrome). With Node.js, you can build scalable and high-performance

web applications, APIs, and even real-time services like chat apps.

📌 Example:

If you write a simple HTTP server in Node.js, you can serve a webpage without using a

traditional web server like Apache:

const http = require('http');

http.createServer((req, res) => {

res.end('Hello from Node.js server!');

}).listen(3000);

EventEmitter allows objects to emit named events and listen for them.

Example:

const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('greet', (name) => {

console.log(`Hello, ${name}!`);

});

emitter.emit('greet', 'Alice');

Output: Hello, Alice!

It’s fundamental for asynchronous communication in Node.js.

Process management means keeping your app running reliably, restarting it if it crashes, and

managing multiple instances.

PM2 is a popular Node.js process manager that:

• Restarts apps on crashes or code changes
• Manages clustering (multi-core usage)
• Offers logs and monitoring dashboards
• Supports zero-downtime reloads

Run your app with PM2 like this:

pm2 start app.js

pm2 monit

Mongoose is an ODM (Object Data Modeling) library for MongoDB in Node.js. It provides:

• Schema-based data modeling
• Validation
• Middleware (hooks)
• Easy querying and relationship management

You define schemas and models to interact with MongoDB more intuitively.

ge: Number,

createdAt: { type: Date, default: Date.now }

});

const User = mongoose.model('User', userSchema);

// Usage example

sync function createUser() {

const user = new User({ name: 'Alice', email: 'alice@example.com',

ge: 25 });

wait user.save();

console.log('User saved');

}

Answer: nd allows async testing. It does not provide assertions, so it’s often paired with assertion libraries like Chai.

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

PM2 is a popular production process manager for Node.js applications. It helps you:

• Manage and keep apps alive forever (auto-restart on crashes).
• Run apps in cluster mode easily.
• Monitor resource usage (CPU, memory).
• Handle zero-downtime reloads.

npm install pm2 -g

pm2 start app.js -i max # Runs in cluster mode with max CPU cores

The V8 engine is a high-performance JavaScript engine developed by Google for Chrome.

Node.js uses it to compile and run JavaScript code on the server side. It converts JS code

into machine code, making it fast and efficient.

📌 Use Case:

When you run a .js file with Node.js, the V8 engine compiles your code into machine code

behind the scenes.

Load balancing distributes incoming requests across multiple server instances to:

• Improve performance
• Increase availability and fault tolerance

In Node.js, you can:

• Use the cluster module to spawn workers on multiple CPU cores.
• Use external load balancers like Nginx, HAProxy, or cloud load balancers.
• PM2 also supports clustering with:

pm2 start app.js -i max

ssert style: ssert.equal(result, 5);

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• PUT: Replaces the entire resource with the data sent.
• If a field is missing in the request, it may get erased.
• Idempotent (same request repeated yields same result).
• PATCH: Applies partial updates to the resource.
• Only changes the fields specified.
• Not necessarily idempotent.

Example: Updating user email.

• PUT /users/1 with { "name": "Alice" } replaces whole user — email might

get removed.

• PATCH /users/1 with { "email": "new@example.com" } updates just the

email.

Sequelize is a popular ORM for relational databases like MySQL, PostgreSQL, SQLite, and

MSSQL.

It allows you to:

• Define models with JavaScript classes
• Handle migrations and schema changes
• Write complex queries using JavaScript instead of raw SQL

Supertest is a library for testing HTTP APIs, especially Express apps.

It allows you to simulate HTTP requests and assert on responses.

Example:

const request = require('supertest');
const app = require('../app'); // Your Express app

describe('GET /users', () => {

it('should return 200 and a list of users', (done) => {

request(app)

.get('/users')

.expect(200)

.expect('Content-Type', /json/)

.end((err, res) => {

if (err) return done(err);

done();

});

});

});

Backpressure happens when data is produced faster than it can be consumed downstream.

In Node.js streams, it's a built-in mechanism to:

• Pause the readable stream when the writable stream is overwhelmed.
• Prevent memory overload and crashes.

This flow control allows producers and consumers to work in sync.

sync/await provides a cleaner syntax for handling asynchronous code, making it look

synchronous and easier to read compared to nested callbacks or promise chains.

sync function fetchData() {

try {

const data = await someAsyncFunction();

console.log(data);

} catch (err) {

console.error(err);

}
}

synchronous operations in a single thread, constantly checking for events (e.g., incoming

data, timers) and executing associated callbacks.

📌 Example:

setTimeout(() => {

console.log('Executed after 2 seconds');

}, 2000);

This callback is scheduled by the event loop and executed when the time is up.

nalysis. ESM is the modern standard but Node.js supports both.

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: dotenv is a library to load environment variables from a .env file into process.env.

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Test coverage shows how much of your code is tested (lines, branches, functions).

Tools to measure:

• Istanbul/nyc: Most popular coverage tool.
• Jest: Has built-in coverage reports.

Run coverage with nyc:

nyc mocha

It outputs stats like:

• % of lines covered
• % of functions covered
• % of branches covered

Security in Node.js

Answer: nodemon is a development tool that automatically restarts your Node.js app when file changes are detected—great for faster development cycles. It’s not recommended for production. Usage: nodemon app.js

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• Synchronous functions block the execution until they finish.
• Asynchronous functions allow other code to run while waiting for operations (like

I/O) to complete.

// Synchronous (blocks event loop)

const data = fs.readFileSync('file.txt');

// Asynchronous (non-blocking)

fs.readFile('file.txt', (err, data) => {

if (err) throw err;

console.log(data);

});

Answer: It specifies the entry point file of a package (default is index.js). When someone imports your package, Node.js loads the file in main.

What interviewers expect

• A clear definition tied to Node.js in Node.js projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production Node.js application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in Node.js architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

CI/CD stands for Continuous Integration and Continuous Deployment.

• CI: Automatically build and test your Node.js app every time you push code (e.g.,

GitHub Actions, Jenkins).

• CD: Automatically deploy the app to production or staging after tests pass.

Benefits:

• Catch bugs early
• Fast, repeatable releases
• Automated testing and deployment pipelines

Typical pipeline steps: