Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Netflix · Node Js
Practice Node Js questions specifically asked in Netflix interviews – ideal for online test preparation, technical rounds and final HR discussions.
Questions
35
Tagged for this company + subject
Company
Netflix
View company-wise questions
Subject
Node Js
Explore topic-wise practice
Go through each question and its explanation. Use this page for targeted revision just before your Netflix Node Js round.
Node.js uses an event-driven, non-blocking I/O model. Incoming client requests go into an Event Queue, and the Event Loop processes them. Simple tasks run directly; complex or blocking tasks are handled by background threads in a thread pool. Once completed, results are sent back via callbacks or Promises.
For complete preparation, combine this company + subject page with full company-wise practice and subject-wise practice. You can also explore other companies and topics from the links below.
A callback is a function passed as an argument to another function, executed once a task completes. It prevents blocking operations and allows asynchronous execution. However, deeply nested callbacks can lead to 'callback hell'.
fs.readFile('file.txt', (err, data) => { if (err) throw err; console.log(data.toString()); });First, import Express, create an app using `express()`, define routes, and start listening on a port. Express automatically handles HTTP requests and responses.
const express=require('express');
const app=express();
app.get('/',(req,res)=>res.send('Hello World'));
app.listen(3000);Callback hell occurs when multiple asynchronous functions are nested within each other, creating deep and unreadable code. It can be solved by using Promises or async/await for cleaner control flow.
// Callback Hell Example
fs.readFile('a.txt', () => {
fs.readFile('b.txt', () => {
fs.readFile('c.txt', () => {
console.log('done');
});
});
});Both create new processes. `spawn()` launches a new process with a given command. `fork()` is a special case of `spawn()` that creates a new Node.js instance for parallel execution, ideal for running multiple workers.
const { fork, spawn } = require('child_process');
const child = fork('worker.js'); // new Node process
const run = spawn('ls', ['-lh']); // system commandPiping connects the output of one stream directly into another stream, commonly used to transfer data efficiently between files or network responses. It eliminates manual data handling.
const fs = require('fs');
fs.createReadStream('input.txt').pipe(fs.createWriteStream('output.txt'));Middleware functions in Node.js (especially in Express) process incoming requests before they reach route handlers. They can modify requests, add headers, handle authentication, or terminate the request-response cycle.
app.use((req,res,next)=>{
console.log('Request Time:', Date.now());
next();
});The assert module helps test conditions in code. It throws errors if an expression evaluates to false, making it useful for debugging and creating unit tests in Node.js.
const assert = require('assert');
assert.strictEqual(2 + 2, 4);Node.js is used for real-time chat apps, streaming platforms, IoT systems, single-page applications, APIs, and microservices due to its scalability and event-driven nature.
Use the HTTP module, call `createServer()` with a callback that handles requests and responses, and listen on a port.
const http=require('http');
http.createServer((req,res)=>{
res.write('Hello World');
res.end();
}).listen(8080);Node.js is fast, scalable, and event-driven. It handles many concurrent connections using non-blocking I/O, making it ideal for real-time applications. Its single-threaded model with the V8 engine ensures efficiency.
The `fork()` method in the child_process module creates a new Node.js process that runs a separate script. It’s useful for scaling CPU-bound tasks or running isolated background jobs.
const { fork } = require('child_process');
const worker = fork('worker.js');
worker.on('message', msg => console.log('Message:', msg));Node.js runs JavaScript on a single thread but can create child processes using `child_process` or worker threads. These allow parallel execution without blocking the event loop.
const { Worker } = require('worker_threads');
new Worker('./task.js');You can use console.time/console.timeEnd or performance.now() to measure how long async operations take. These tools help track performance bottlenecks in APIs or I/O-heavy code.
console.time('fetch');
await fetch('https://api.com');
console.timeEnd('fetch');MongoDB connects through the official driver or Mongoose. The `connect()` function establishes a persistent connection, and once connected, it can perform CRUD operations efficiently.
const mongoose=require('mongoose');
mongoose.connect('mongodb://localhost:27017/mydb');Node.js implements sandboxing to isolate code, uses TLS/SSL for encryption, environment variables for secrets, and libraries like Helmet for securing HTTP headers. Regular dependency audits also prevent known vulnerabilities.
PM2 manages Node.js processes, restarts apps on crashes, and supports cluster mode for multi-core scaling. It simplifies logging, monitoring, and zero-downtime deployments.
pm2 start app.js -i max pm2 monit
You can measure performance using tools like `clinic.js`, Node’s `--prof` flag, or APM tools (Datadog, New Relic). Benchmark code using console.time() or the Performance API to detect slow functions.
Graceful shutdown ensures open connections and background tasks finish before exiting. You can listen for signals like SIGINT or SIGTERM and close servers cleanly.
process.on('SIGINT',()=>{
server.close(()=>{
console.log('Server closed gracefully');
process.exit(0);
});
});Using streams allows data to be processed in chunks instead of loading the entire file into memory. This improves performance and reduces memory usage, especially for videos or large logs.
fs.createReadStream('video.mp4').pipe(res);Use the cluster module or PM2 to spawn multiple worker processes. Each worker handles requests independently, improving concurrency and performance.
import cluster from 'cluster';
import os from 'os';
if(cluster.isPrimary){os.cpus().forEach(()=>cluster.fork());}Use the Chrome DevTools Heap Snapshot or tools like `clinic heapprofiler` to track object growth. Common causes are global variables, unclosed streams, or forgotten timers.
Popular tools include Sentry, Datadog, and LogRocket. They capture errors, performance traces, and stack info in real-time for debugging and analytics.
Buffers handle raw binary data in Node.js. They are useful when dealing with file streams, TCP packets, or image data. Buffers are fixed-size byte arrays allocated outside the V8 heap for efficient memory handling.
const buf = Buffer.from('Hello');
console.log(buf.toString());Control flow refers to managing asynchronous operations’ order and results. Since Node.js doesn’t block execution, control flow ensures callbacks, promises, and async/await handle dependencies correctly in async code.
The Redis module allows connecting to Redis servers for caching, message brokering, and session storage. It improves response speed by storing frequent queries in memory instead of querying the database repeatedly.
const redis=require('redis');
const client=redis.createClient();
client.set('user','John');Node.js is faster, supports asynchronous I/O, and allows using JavaScript both on frontend and backend. It’s lightweight, scalable, and ideal for data-intensive applications. In contrast, Java/PHP rely on multi-threaded blocking architectures.
Node.js is an open-source, cross-platform JavaScript runtime environment built on Chrome’s V8 engine. It allows running JavaScript on the server side instead of just in the browser. It is commonly used for building web servers, APIs, streaming applications, and real-time apps like chat or online games.
`fs.readFile()` reads the entire file into memory before processing, making it suitable for small files. `fs.createReadStream()` reads chunks of data as streams, ideal for large files or real-time data transfer.
fs.createReadStream('large.txt').pipe(fs.createWriteStream('copy.txt'));Logging helps track app behavior and diagnose problems. Libraries like Winston or Pino provide log levels (info, warn, error) and can output structured JSON for log management systems like Datadog or CloudWatch.
const winston = require('winston');
const logger = winston.createLogger({ level:'info', transports:[ new winston.transports.Console() ] });
logger.info('Server started');Use caching (Redis or in-memory), pagination, compression, connection pooling, and asynchronous code. Avoid blocking calls, use async/await efficiently, and enable GZIP compression for responses. Profiling tools like Clinic.js help spot slow endpoints.
Event-driven programming means the flow of the program is determined by events such as user actions or messages from other programs. In Node.js, events trigger callback functions through the EventEmitter system, allowing non-blocking, asynchronous behavior.
You mark a function as async and use await to pause execution until a promise resolves. This makes asynchronous code look synchronous, improving readability and error handling.
async function loadData(){
try{
const res=await fetch('https://api.com');
const data=await res.json();
console.log(data);
}catch(err){console.error(err);}
}To connect MongoDB with Node.js, use the official MongoDB driver or Mongoose. You create a client using MongoClient, provide the connection URL, and call `connect()`. Mongoose adds schema and validation features.
const { MongoClient } = require('mongodb');
const uri = 'mongodb://localhost:27017';
const client = new MongoClient(uri);
await client.connect();
console.log('Connected to MongoDB');Node.js uses try-catch for synchronous errors and callback or Promise rejection handlers for async code. Uncaught errors crash the process, so using centralized error middleware or process event handlers (`process.on('uncaughtException')`) ensures graceful recovery.
app.use((err,req,res,next)=>{
console.error(err.stack);
res.status(500).send('Something broke!');
});