MERN Stack Interview Questions and Answers You Must Prepare in 2026

Middleware is a function that runs between the request coming in and the response going out. It’s commonly used for tasks like authentication, logging, request validation, and error handling.

Routing in Express maps HTTP requests to specific handler functions. Routes can read data from URL parameters, query strings, or the request body, depending on how the API is designed. Using routers helps keep routes modular and organized.

Centralized error handling is done using a special middleware that catches errors in one place. Instead of handling errors inside every route, errors are passed to this middleware, which sends a consistent error response to the client.

Validation is usually done using middleware before the request reaches the main logic. This ensures required fields are present and data is in the correct format, preventing bad requests from reaching the business logic.

CORS is configured using middleware to control which domains can access the API. It’s needed to allow frontend applications hosted on different origins to safely communicate with the backend without security issues.

Express is a lightweight framework built on top of Node.js to create APIs easily. It’s used in MERN because it simplifies routing, middleware handling, and request-response logic, which makes backend development faster and more structured.

• var is function-scoped and can be redeclared, which can lead to bugs.
• let and const are block-scoped and safer to use.
• const is preferred when a variable should not be reassigned, while let is used when reassignment is needed.

A closure is created when a function remembers variables from its outer scope even after that scope has finished executing. Closures commonly appear in React hooks, event handlers, and callbacks, as well as in Node for async operations and middleware.

The event loop allows JavaScript to handle async tasks without blocking execution. In the browser, it manages UI events and async callbacks, while in Node.js it also handles I/O operations like file reads and network requests using non-blocking APIs.

A Promise represents a value that will be available in the future. then and catch handle results using callbacks, while async/await provides a cleaner, more readable way to write asynchronous code that looks synchronous.

In JavaScript, objects inherit properties and methods from other objects through prototypes. Instead of classical inheritance, JavaScript uses this prototype chain to share behavior between objects efficiently.

Hoisting is JavaScript’s behavior of moving variable and function declarations to the top of their scope during execution. This matters because variables declared with var can be accessed before declaration, often causing unexpected bugs.

A shallow copy duplicates only the top-level values, so nested objects still reference the original data. A deep copy creates a completely independent copy, which prevents unintended side effects when modifying nested structures.

Performance can be improved by reducing unnecessary re-renders, avoiding heavy computations in render cycles, using memoization where needed, and loading only required data or components instead of everything at once.

You can check out more such questions at: JavaScript Interview Questions and Answers (2026)

MongoDB is a good choice when data is flexible or changes often, and strict table structures are not required. It works well for applications with fast development cycles, JSON-like data, and high read or write scalability.

Embedded documents are used when data is closely related and usually accessed together. References are better when data is shared across collections or can grow large. The decision is based on access patterns and data size.

An index helps MongoDB find data faster without scanning the entire collection. It improves query performance, especially for frequently searched fields, but too many indexes can slow down writes.

The aggregation pipeline is used to process and transform data step by step. It’s used for reporting, analytics, and complex queries like grouping, filtering, and calculating totals directly in the database.

$match filters documents, $group groups data and performs calculations, and $project shapes the output by selecting or modifying fields. These stages are often combined to build powerful data queries.

For one-to-many relationships, embedding is used when data is small and tightly linked, otherwise references are used. For many-to-many relationships, references are usually preferred to avoid data duplication and keep updates manageable.

JWT (JSON Web Token) is a token used to prove a user’s identity after login. Once the user logs in, the backend generates a token and sends it to the frontend. The frontend sends this token with every protected API request, and the backend verifies it before allowing access.

Cookies are more secure because they can be HTTP-only and protected from JavaScript access. LocalStorage is easier to use but more vulnerable to XSS attacks. In production apps, cookies are often preferred for better security.

Protected routes are implemented by checking whether the user is authenticated before rendering a page. If the user is not logged in, they are redirected to the login page. This is usually done using route guards or wrapper components.

API calls are usually kept in a separate service or utility file instead of inside components. This keeps components clean and makes API logic reusable. Common headers like auth tokens are also handled in one place.

When a token expires, the frontend detects it from the API response. A refresh token is then used to request a new access token without forcing the user to log in again. This keeps sessions smooth while maintaining security.

RBAC is implemented by checking the user’s role after authentication. Middleware is used to allow or block access to routes based on roles like admin or user. This ensures users can only access what they’re permitted to.

First, a React form is used to collect user input and manage it using state. On submit, the data is sent to an Express API through a POST or PUT request. The backend validates the data, performs the database operation in MongoDB, and sends a response back, which the frontend uses to update the UI.

Pagination is handled on the backend using query parameters like page and limit. MongoDB uses skip and limit to fetch only the required records. The frontend sends these values, receives paginated data, and updates the UI with page controls.

Filters and sort options are sent from the React UI as query parameters. The backend applies these conditions while querying MongoDB. This keeps heavy logic on the server and ensures the frontend only renders clean, ready-to-use data.

Basic validation is done on the frontend to improve user experience, such as required fields or format checks. The same rules are enforced again on the backend to ensure security and data integrity. Backend validation is always treated as the final authority.

The frontend sends the file using a form-data request. Express handles the upload using middleware and stores the file locally or in cloud storage. The stored file’s URL is then saved and returned so the frontend can display the image.

Search is handled on the backend using indexed fields or text search. The frontend sends the search keyword to the API, which queries MongoDB and returns matching results. The UI then updates dynamically based on the response.

In a typical MERN architecture, the React app runs on the client and handles all user interactions. It talks to a Node and Express backend through REST APIs, which apply business logic and interact with MongoDB to store or fetch data. The backend then sends JSON responses back to the frontend, completing the request-response cycle.

A MERN stack developer works across both frontend and backend. This includes building UI components in React, creating APIs using Node and Express, and managing data with MongoDB. They also handle things like authentication, connecting frontend to backend, fixing bugs, and making sure the application performs well.

A MERN project is usually structured by separating the frontend and backend into distinct folders or repositories. The frontend contains React components, pages, and state management, while the backend includes routes, controllers, models, and middleware. Shared configurations, such as environment variables and API endpoints, are managed carefully to keep the codebase clean and maintainable.

You can also check out: Top Full Stack Developer Interview Questions (2026)

The MERN stack is a full-stack setup where React handles the frontend, Node and Express handle the backend APIs, and MongoDB stores data. It’s popular because JavaScript is used everywhere, so data flows smoothly from UI to database without heavy conversions. Teams prefer it because it’s fast to build, easy to iterate on, and well-suited for modern, API-driven applications.

References are used to link documents across collections using object IDs. Population allows related data to be automatically fetched when querying, which helps keep schemas clean while still accessing related information when needed.

Mongoose is an Object Data Modeling (ODM) library used with MongoDB in Node.js applications. It provides schemas, validations, and a structured way to interact with the database, which makes code easier to manage compared to using raw MongoDB queries.

Schema validations ensure that data saved to the database follows certain rules. They are used to check things like required fields, data types, value ranges, or formats, helping prevent invalid or incomplete data from being stored.

Pre and post hooks are functions that run before or after certain actions, like saving or updating data. They are commonly used for tasks such as hashing passwords before saving or logging changes after an update.

Performance issues are reduced by using proper indexes, limiting returned fields, avoiding unnecessary population, and designing schemas based on access patterns. Monitoring slow queries and optimizing them early also helps keep applications responsive.

The event loop is what allows Node.js to handle multiple tasks without blocking the main thread. It manages asynchronous operations like API calls, file reads, and timers, making Node efficient and scalable even though it runs on a single thread.

Node handles concurrency by using non-blocking asynchronous operations. While the main thread stays free, time-consuming tasks like I/O are handled in the background, and callbacks are executed when those tasks finish.

Blocking code stops execution until a task is completed, which can slow down the entire application. Non-blocking code allows other tasks to run while waiting, which is why it’s preferred in Node for better performance.

Streams allow data to be processed in chunks instead of loading everything into memory at once. They are commonly used for handling large files, video streaming, or data transfer where performance and memory efficiency matter.

With Promises, errors are handled using .catch(). With async/await, errors are handled using try-catch blocks. Using proper error handling ensures failures don’t crash the server and are logged or returned cleanly.

Environment variables are stored outside the codebase using tools like .env files and accessed through process.env. Sensitive values such as API keys and secrets are never hard-coded and are excluded from version control.

Controlled components store form data in React state and give full control over inputs. Uncontrolled components let the DOM manage the data and are useful for simple forms where tight control is not required.

React is a JavaScript library used to build user interfaces using components. It uses a Virtual DOM to track changes efficiently and only updates the parts of the UI that actually change. This makes re-rendering faster and improves performance.

Props are used to pass data from a parent component to a child and are read-only. State is managed inside a component and can change over time, usually based on user actions or API responses.

Lifting state up means moving shared state to the closest common parent component. This is useful when multiple components need access to the same data and helps keep data consistent across the UI.

useEffect is used to run side effects like API calls or subscriptions. It runs after the component renders, and its execution depends on the dependency array provided.

The dependency array controls when useEffect runs. An empty array runs it only once, specific values run it when those values change, and no array runs it after every render.

useMemo is used to memoize expensive values or calculations. useCallback is used to memoize functions so they don’t get recreated on every render. Both help improve performance when used correctly.

Unnecessary re-renders can be reduced by memoizing components, using useMemo and useCallback, avoiding unnecessary state updates, and keeping component state minimal and well-structured.

Context API works well for small to medium apps with simple global state. Redux is better for large applications with complex state logic, multiple data sources, and strict state management needs.

A reducer is a function that updates the state based on actions. Immutability is important because React depends on state changes to detect updates, and mutating state directly can cause bugs and unpredictable UI behavior.