Node.js Backend Development Flashcards

Question 1

What is Node.js and what is it commonly used for in backend development?

Accepted Answer

Node.js is an open source runtime that lets developers run JavaScript outside a web browser, using the V8 engine that powers Chrome. It is commonly used to build backend services, APIs, and command line tools. Its non-blocking, event driven design suits applications that handle many simultaneous network connections efficiently.

Question 2

What is the event loop in Node.js and why does it matter?

Accepted Answer

The event loop is the mechanism that lets Node.js handle non-blocking input and output while running JavaScript on a single thread. It checks a queue of finished operations and runs their callbacks when the call stack is empty. Because slow work does not block the thread, one process can serve many clients at once.

Question 3

What is the difference between blocking and non-blocking code in Node.js?

Accepted Answer

Blocking code waits for an operation to finish before the next line runs, so the thread sits idle during slow work. Non-blocking code starts the operation, registers a callback or promise, and continues running other work. Node.js favors non-blocking APIs so one thread can keep many requests in progress together.

Question 4

What is a callback function and how is it used in Node.js code?

Accepted Answer

A callback is a function you pass as an argument to another function so it can run later. Node.js core APIs use the error first pattern, where the first parameter holds an error or null and the second holds the result. Promises and async await offer a cleaner alternative to deeply nested callbacks.

Question 5

How do promises differ from callbacks for handling asynchronous results?

Accepted Answer

A promise is an object that represents a value that will be available later. Instead of passing a callback into the function, you attach handlers with then and catch, which can be chained in sequence. Errors propagate down the chain, so one catch can handle failures from several steps.

Question 6

What does async and await do in JavaScript code running on Node.js?

Accepted Answer

The async keyword marks a function as returning a promise, and the await keyword pauses that function until a promise settles, then yields its result. This lets asynchronous code read almost like synchronous code. Errors thrown or rejected inside an async function can be handled with try and catch blocks.

Question 7

What are timers such as setTimeout and setImmediate used for in Node.js?

Accepted Answer

Timers schedule a callback to run after a delay or during a later phase of the event loop. setTimeout runs its callback after at least the given number of milliseconds, while setImmediate runs after the current poll phase completes. Timers are useful for retries, debouncing, and deferring low priority work.

Question 8

Why should you avoid heavy CPU work on the main thread in Node.js?

Accepted Answer

Heavy CPU work on the main thread blocks the event loop, so no other requests can be processed until the computation finishes. Typical examples include large image processing, complex encryption loops, or huge JSON parsing. Developers usually move such work to worker threads, a separate process, or a dedicated service to keep responses fast.

Question 9

What is the difference between CommonJS and ES modules in Node.js?

Accepted Answer

CommonJS uses require to load modules and module.exports to expose values, and it loads them synchronously. ES modules use import and export statements, and they are the standard module system defined by the JavaScript language. Node.js supports both, and a package.json type field or file extension determines which system a file uses.

Question 10

What is the purpose of the package.json file in a Node.js project?

Accepted Answer

The package.json file is the manifest for a Node.js project, describing its name, version, entry point, scripts, and dependencies. npm reads it to install required packages and run commands defined under scripts. Keeping it accurate lets teammates reproduce the same environment with a single install command.

Question 11

What is the difference between dependencies and devDependencies in package.json?

Accepted Answer

Dependencies are packages the application needs at runtime, such as a web framework or database driver. devDependencies are tools needed only during development or testing, such as test runners, linters, or build tools. Production installs typically skip devDependencies, which keeps deployed environments smaller.

Question 12

What does the semantic versioning scheme major minor patch mean for npm packages?

Accepted Answer

Semantic versioning numbers releases as major.minor.patch. A major increase signals breaking changes, a minor increase adds backward compatible features, and a patch increase fixes bugs without changing behavior. Version ranges like caret and tilde let npm accept compatible updates automatically within set limits.

Question 13

Why is the package-lock.json file important for reproducible installs?

Accepted Answer

The package-lock.json file records the exact version of every installed package, including nested dependencies, along with integrity hashes. When teammates or servers run npm ci or npm install, npm uses these recorded versions instead of resolving newer ones. This makes builds consistent across machines and over time.

Question 14

How does require resolve a module name like express versus a relative path like ./utils?

Accepted Answer

A bare name such as express is looked up in node_modules folders, starting in the current directory and moving up the tree. A relative path such as ./utils starts from the file's own directory and is resolved to a file, adding extensions like .js or an index file if needed. Core module names such as fs are checked first.

Question 15

What is the purpose of npm scripts defined in package.json?

Accepted Answer

npm scripts are named shortcuts for commands, defined under the scripts field, such as start, test, or build. You run them with npm run followed by the name, while start and test can be run with npm start and npm test. They standardize how team members launch, test, and build the project.

Question 16

What is a security risk of installing many third party npm packages?

Accepted Answer

Each third party package can contain vulnerabilities or malicious code, and dependencies often pull in further packages you never reviewed. A compromised package can leak secrets or run unwanted code during installation. Teams reduce this risk by reviewing dependencies, keeping them updated, and running npm audit to check for known issues.

Question 17

Which core modules handle files, network servers, and paths in Node.js?

Accepted Answer

The fs module reads, writes, and manages files and directories, both with callbacks and promise based APIs. The http module creates servers and makes outgoing requests, and the path module builds and parses file system paths in a platform safe way. Node.js core modules are built in, so they need no npm install.

Question 18

What is a Buffer in Node.js and why is it used?

Accepted Answer

A Buffer is a fixed size chunk of raw binary data, used when working with bytes such as file contents, network packets, or images. Buffers let Node.js handle binary input and output that plain strings cannot represent safely. You can convert between buffers and strings using a specified encoding such as utf8.

Question 19

What are streams in Node.js and what problem do they solve?

Accepted Answer

Streams are objects that process data piece by piece as it arrives, rather than loading the entire dataset into memory at once. They solve the problem of handling large files or long network transfers without exhausting memory. Node.js has readable, writable, duplex, and transform streams that can be connected together.

Question 20

How does piping one stream into another help with backpressure?

Accepted Answer

Piping connects a readable stream to a writable stream and automatically pauses the source when the destination's internal buffer is full. This behavior is called backpressure, and it prevents fast producers from overwhelming slow consumers. Resuming happens once the destination drains, so memory use stays bounded.

Question 21

What is the practical difference between fs.readFile and fs.createReadStream for large files?

Accepted Answer

The fs.readFile function loads the entire file into memory and delivers it once through a single callback or promise. The fs.createReadStream function returns a readable stream that emits small chunks as they are read, so memory use stays low. Streams are usually better for large files, while readFile is simpler for small configuration files.

Question 22

How do you read a JSON file using the built in fs module with async code?

Accepted Answer

Use fs.promises.readFile or the promise based fs/promises import with await, passing the path and encoding utf8 to receive a string. Then call JSON.parse on that string to convert it into a JavaScript object. Wrap the call in try and catch, since a missing file or malformed JSON both throw errors.

Question 23

What is the purpose of the http module's createServer method?

Accepted Answer

The http.createServer method creates an HTTP server that calls a request listener each time a client sends a request. The listener receives a request object with the method, URL, and headers, plus a response object used to write the status, headers, and body. Calling server.listen with a port number starts accepting connections.

Question 24

How can a Node.js program read environment variables such as a port number?

Accepted Answer

Node.js exposes environment variables through the process.env object, so process.env.PORT returns the value set in the shell or hosting platform. Values are always strings, so convert them to numbers when needed, and provide a fallback with the logical or operator. Keep secrets out of source code and load them from the environment instead.

Question 25

What is Express and what role does it play in a Node.js backend?

Accepted Answer

Express is a minimal and widely used web framework for Node.js that simplifies building HTTP servers and APIs. It provides a routing system, middleware support, and helpers for reading requests and sending responses. Compared with raw http, it removes much of the repetitive setup code while staying unopinionated about structure.

Question 26

What is middleware in Express and how does a request move through it?

Accepted Answer

Middleware is a function with access to the request, the response, and a next function that passes control onward. Requests move through middleware in registration order, and each function can modify the request, end the response, or call next. Forgetting to call next or send a response leaves the request hanging.

Question 27

How do route parameters and query strings differ in an Express route?

Accepted Answer

Route parameters are named segments in the path, such as /users/:id, and Express exposes them through req.params. Query strings come after a question mark, such as /search?term=books, and are exposed through req.query. Use parameters to identify a resource and query strings for optional filtering or sorting.

Question 28

What is the purpose of Express Router and why group routes into separate files?

Accepted Answer

Express Router creates a modular, mountable set of routes that can be attached to an application under a shared path prefix. Grouping routes into separate files keeps large applications organized, lets teams work on features independently, and makes each module easier to test. The main app then mounts each router with app.use.

Question 29

How does Express error handling middleware differ from regular middleware?

Accepted Answer

Error handling middleware is defined with four parameters, err, req, res, and next, which signals Express to treat it specially. It is skipped during normal request flow and runs only when an error is passed to next or thrown in synchronous code. It is usually registered after all routes so it catches their failures.

Question 30

Why should you validate request bodies before using them in an Express handler?

Accepted Answer

Request bodies come from clients, so their shape and types cannot be trusted without checking. Validation rejects missing fields, wrong types, or oversized values before they reach business logic or a database. Respond with a clear 400 status for invalid input, and use a validation library or schema to keep rules consistent.

Question 31

What does the express.json middleware do for incoming requests?

Accepted Answer

The express.json middleware parses requests whose Content-Type header is application/json and places the resulting object on req.body. Without it, req.body is undefined for JSON payloads, so handlers cannot read submitted data. It should be registered before any route that expects a JSON body.

Question 32

How do you serve static files such as images and CSS with Express?

Accepted Answer

Use the built in express.static middleware and pass it the folder that holds your public files, such as app.use(express.static('public')). Requests matching a file in that folder receive the file directly, and other requests continue to the next middleware or route. Avoid placing sensitive files in the served folder.

Question 33

Why do backend applications use a database connection pool?

Accepted Answer

A connection pool keeps a set of open database connections ready for reuse, so each request does not pay the cost of opening and closing a new connection. The pool limits how many connections the application opens at once, which protects the database from overload.

Question 34

What is SQL injection and how do parameterized queries prevent it?

Accepted Answer

SQL injection happens when untrusted input is concatenated into a query string, letting an attacker change the meaning of the SQL. Parameterized queries send the SQL text and the values separately, so the database treats user input strictly as data. Never build queries by joining raw request values into strings.

Question 35

Why should passwords be hashed with a slow algorithm instead of stored in plain text?

Accepted Answer

Plain text storage exposes every account to anyone who can read the database, so passwords are stored as one way hashes instead. A hash turns the password into a fixed digest that cannot be reversed directly. Deliberately slow algorithms such as bcrypt, scrypt, or Argon2 make guessing attacks costly.

Question 36

What is the difference between unit tests and integration tests in a backend project?

Accepted Answer

Unit tests check a single function or module in isolation, usually replacing its dependencies with fakes or stubs. Integration tests check how several parts work together, such as a route handler talking to a real database. Unit tests run quickly and pinpoint failures, while integration tests catch problems at the boundaries between components.

Question 37

Why should backend tests use a separate test database instead of production data?

Accepted Answer

Tests often create, change, and delete records, which could corrupt or expose real customer data if they ran against production. A separate test database lets each run start from a known state, so results are repeatable. Teams usually reset or seed the test data before each test run.

Question 38

What is an unhandled promise rejection and why does it matter in Node.js?

Accepted Answer

An unhandled promise rejection occurs when a promise fails and no catch handler or try and catch block deals with the error. Modern Node.js versions treat this as a fatal error by default and terminate the process, which takes down every active request. Attach catch handlers or wrap awaited calls to keep failures contained.

Question 39

What is a health check endpoint and why do hosting platforms use it?

Accepted Answer

A health check endpoint is a simple route, often at /health, that returns a success status when the application can serve requests. Hosting platforms and load balancers call it periodically to decide whether an instance is healthy. If it fails repeatedly, the platform can restart or stop sending traffic to that instance.

Question 40

What does graceful shutdown mean for a Node.js server?

Accepted Answer

Graceful shutdown means that when the process receives a termination signal such as SIGTERM, it stops accepting new connections, finishes in-flight requests, and closes resources like database pools before exiting. This avoids dropped requests and half written data during deployments or restarts. The process should exit with a clear status code once cleanup completes.

Node.js Backend Development Flashcards

1Node.js runtime and asynchronous basics

2Modules and package management

3Core modules, buffers, and streams

4Express routing and middleware

5Databases, security, testing, and deployment

Learning Resources