Question 1

What is MongoDB and how does its document-based model work?

Accepted Answer

MongoDB is a source-available, document-oriented NoSQL database. Instead of storing data in tables and rows like relational databases, MongoDB stores data in flexible, JSON-like documents (which are represented internally as BSON - Binary JSON). This model allows documents in the same collection to have different fields, supporting dynamic schemas and nested subdocuments, making it highly compatible with modern object-oriented languages.

Question 2

Explain the difference between SQL and NoSQL databases.

Accepted Answer

- SQL databases (relational) are table-based with rigid, structured schemas, enforcing ACID properties and relational integrity via foreign keys, ideal for complex transactions (e.g. banking).
- NoSQL databases (non-relational) are document, key-value, column, or graph-based with dynamic schemas, prioritizing horizontal scalability and write speeds, ideal for unstructured data and rapid development.

Question 3

What is BSON and how does it differ from JSON?

Accepted Answer

BSON is the binary serialization format used to store documents in MongoDB. Unlike standard text-based JSON, BSON includes extensions for additional data types (like Date, ObjectId, Decimal128, and binary data) and is optimized for speed, allowing MongoDB to traverse and query document fields without parsing text strings.

Question 4

What is an ObjectId in MongoDB and what are its components?

Accepted Answer

An `ObjectId` is a unique 12-byte identifier automatically generated as the primary key (`_id`) for every document. Its components are:
- 4-byte timestamp: representing the document's creation time.
- 5-byte random value: unique per machine and process.
- 3-byte counter: starting with a random value and incrementing sequentially.

Question 5

Explain how to perform basic CRUD operations in MongoDB.

Accepted Answer

CRUD stands for Create, Read, Update, Delete:
- Create: `db.collection.insertOne(doc)` or `insertMany([doc1, doc2])`.
- Read: `db.collection.find(filter)`.
- Update: `db.collection.updateOne(filter, { $set: updateDoc })`.
- Delete: `db.collection.deleteOne(filter)`.

Question 6

What is an Index in MongoDB and why is it important?

Accepted Answer

An index is a special data structure (B-tree) that stores a small fraction of the collection's data in an ordered form, mapping values to documents. It is important because it allows MongoDB to resolve queries efficiently without performing expensive collection scans (checking every document).

Question 7

What is the difference between findOne() and find() in MongoDB?

Accepted Answer

- `findOne()` returns the first single document that matches the query filter directly as an object.
- `find()` returns a cursor pointer. The cursor lets you iterate through matching documents in chunks, supporting chaining methods like `limit()`, `skip()`, and `sort()`.

Question 8

Explain how to use query operators ($gt, $lt, $in, $and, $or) in MongoDB.

Accepted Answer

Query operators perform conditional filtering:
- `$gt`/`$lt`: match values greater/less than a target: `{ age: { $gt: 18 } }`.
- `$in`: match any value in an array: `{ status: { $in: ['active', 'pending'] } }`.
- `$and`/`$or`: combine query clauses: `{ $or: [{ status: 'active' }, { role: 'admin' }] }`.

Question 9

Explain the update operators $set, $unset, $push, and $pull in MongoDB.

Accepted Answer

- `$set`: adds or updates specific document fields without replacing the document.
- `$unset`: deletes specific fields from a document.
- `$push`: appends an item to an array field.
- `$pull`: removes matching items from an array field.

Question 10

What is the difference between embedded documents and references in schema design?

Accepted Answer

- Embedding nested documents captures data directly within the parent document (one-to-few), optimizing read speeds by avoiding database joins.
- Referencing stores documents in separate collections, linking them via IDs (one-to-many/many-to-many), which avoids duplicate data but requires joins (`$lookup`).

Question 11

Explain the use of the limit() and skip() methods in cursor pagination.

Accepted Answer

- `limit(n)` restricts the cursor results to a maximum of `n` documents.
- `skip(n)` skips the first `n` documents. Used together (`find().skip(20).limit(10)`), they implement basic pagination, though `skip` slows down under large offsets.

Question 12

What is the purpose of the primary key field _id in MongoDB?

Accepted Answer

The `_id` field is the mandatory primary key for every document in a collection. If omitted during insertions, MongoDB automatically generates a unique `ObjectId` value for it, ensuring document uniqueness.

Question 13

Explain how to sort search queries in MongoDB.

Accepted Answer

Use the `sort()` method on query cursors. It accepts an object specifying fields and sort directions: `1` for ascending order, and `-1` for descending order: `db.collection.find().sort({ age: 1 })`.

Question 14

What are capped collections in MongoDB?

Accepted Answer

Capped collections are fixed-size collections that support high-throughput, insertion-order operations. Once a capped collection reaches its maximum size, it automatically deletes the oldest documents to make space for new ones, acting like a circular queue.

Question 15

Explain the difference between MongoDB upsert option and regular updates.

Accepted Answer

An `upsert` option (`{ upsert: true }`) is passed to updates. If a document matching the query exists, it updates it. If no document matches, MongoDB creates a new document combining the query filter and update fields.

Question 16

What is the purpose of the database command db.stats()?

Accepted Answer

`db.stats()` returns statistics about the database, including the total database size, average document size, index sizes, and collection counts, which is useful for checking storage use.

Question 17

Explain how to check active queries in MongoDB.

Accepted Answer

Use the `db.currentOp()` administration command. It returns an object containing details about all running database operations, allowing you to identify slow, blocked, or long-running queries.

Question 18

What is the role of the projection parameter in MongoDB queries?

Accepted Answer

Projection specifies which fields to return in query results. You include fields by setting them to `1` or exclude them by setting them to `0` (e.g. `{ name: 1, password: 0 }`), reducing network payload sizes.

Question 19

How do you count documents in a MongoDB collection?

Accepted Answer

Use `db.collection.countDocuments(filter)`. This executes an accurate count of matching documents, which is preferred over legacy methods that read metadata estimates.

Question 20

What are database transactions in NoSQL databases?

Accepted Answer

Transactions allow grouping multiple write operations across collections. MongoDB supports multi-document ACID transactions using sessions, ensuring that either all operations commit successfully or all roll back.

Question 21

Explain the MongoDB Aggregation Pipeline and write a pipeline matching filters.

Accepted Answer

The Aggregation Pipeline is a framework for data aggregation. Documents flow through a multi-stage pipeline that transforms them. Write a pipeline using stages:
```javascript
db.orders.aggregate([
  { $match: { status: "urgent" } },
  { $group: { _id: "$customerId", totalAmount: { $sum: "$price" } } },
  { $sort: { totalAmount: -1 } }
]);
```
This filters orders, groups them by customer summing prices, and sorts them.

Question 22

What are compound indexes and index intersection in MongoDB, and how do they optimize lookups?

Accepted Answer

Compound indexes contain references to multiple fields: `db.collection.createIndex({ status: 1, age: -1 })`. They optimize lookups by supporting queries filtering on both fields sequentially. The query must match the left-to-right order of index fields (equality prefix rule). Index intersection occurs when MongoDB merges results from two separate single-field indexes, though compound indexes are faster.

Question 23

Explain MongoDB Replica Sets and how failover occurs.

Accepted Answer

A Replica Set is a group of MongoDB processes that maintain the same dataset, providing redundancy. It consists of one Primary node (handles all write operations) and multiple Secondary nodes (replicate data asynchronously). If the Primary crashes, the remaining nodes vote in an election to choose a new Primary automatically within seconds.

Question 24

How do you write database unit tests using an in-memory MongoDB server?

Accepted Answer

Use libraries like `mongodb-memory-server`. In test hooks, spin up the virtual MongoDB process, connect mongoose/native drivers, run mutations, assert collections, and stop the process after tests complete, avoiding cleanups on external databases.

Question 25

Explain write concern and read concern properties in MongoDB clusters.

Accepted Answer

- Write Concern controls write confirmation (e.g., `w: 1` confirms writes once saved to primary; `w: "majority"` confirms once saved to a majority of replica nodes).
- Read Concern controls read isolation levels, ensuring clients do not read dirty data from split primaries.

Question 26

Explain how MongoDB executes the explain() command to audit queries.

Accepted Answer

Append `.explain('executionStats')` to a query cursor. It returns query execution details, listing target index scans (`IXSCAN`), collection scans (`COLLSCAN`), scanned documents, and durations to locate bottlenecks.

Question 27

What is index selectiveness and how does it prevent slow queries?

Accepted Answer

Selectiveness measures how effectively an index filters out unrelated documents. An index on fields with high cardinality (unique values like email) is highly selective and fast, whereas fields with low cardinality (like gender) are slow.

Question 28

How do you mock MongoDB queries in unit tests using sinon or jest?

Accepted Answer

Use libraries like `mockingoose` to intercept mongoose calls. Stub find/save methods: `mockingoose(User).toReturn(mockUser, 'findOne')` to return mock JSON payloads directly without database overhead.

Question 29

Explain how MongoDB handles lock concurrency.

Accepted Answer

MongoDB uses the WiredTiger engine, which implements ticket-based optimistic concurrency control. It uses reader-writer locks, allowing concurrent reads but locking documents dynamically during write operations.

Question 30

What is TTL index in MongoDB and when is it configured?

Accepted Answer

A TTL (Time-To-Live) index automatically deletes documents after a set time. Configure it by setting `expireAfterSeconds` on date fields, which is useful for cleaning up sessions or API logs.

Question 31

Explain the role of the database profiler in MongoDB.

Accepted Answer

The database profiler (`db.setProfilingLevel(level)`) logs query execution stats to the `system.profile` collection. Use level `1` to log queries taking longer than a set threshold to identify slow queries in production.

Question 32

What is the difference between $lookup and standard SQL joins?

Accepted Answer

`$lookup` performs left outer joins on collections. It has a high CPU overhead compared to SQL joins because NoSQL tables are not optimized for relations, so schema designs should prioritize embedding over `$lookup`.

Question 33

How do you test database transaction abort flows in MongoDB?

Accepted Answer

Write integration tests that open sessions: `session.startTransaction()`. Perform a series of writes, trigger an error, call `session.abortTransaction()`, and assert that the database rolls back updates completely.

Question 34

Explain how to write custom schema validators in MongoDB.

Accepted Answer

Define `validator` options inside `db.createCollection()`. Use JSON Schema validation schemas to validate incoming document formats, rejecting writes that fail format checks.

Question 35

What is index covered query and how do you achieve it?

Accepted Answer

An index covered query is a query where all matched fields and returned fields exist in the index. You achieve it by projecting only the indexed fields out, letting MongoDB resolve queries without reading the document.

Question 36

How do you handle schema migrations in MongoDB applications?

Accepted Answer

Write migration scripts that read documents, modify attributes, and save changes. Use packages like `migrate-mongo` to track migration history in collections, executing updates sequentially.

Question 37

Explain MongoDB Sharding Architecture, detailing the roles of Config Servers, Query Routers (mongos), and Shard keys.

Accepted Answer

Sharding is MongoDB's solution for horizontal scaling. It distributes data across multiple machines. Components include:
1. Shards: Individual nodes containing a subset of the data.
2. Config Servers: Replicated sets that store metadata and routing rules for the cluster.
3. Query Routers (mongos): Access interfaces that intercept client queries, fetch routing paths from Config Servers, and route queries to the correct Shard.

Selecting a Shard Key is critical. A bad key (like low cardinality or monotonically increasing IDs) creates 'hot shards' where a single node processes all writes, degrading performance. Choose high-cardinality keys with even write distribution (e.g., compound keys combining tenant ID and user hash).

Question 38

How would you design a scalable MongoDB schema for a large e-commerce platform with 10M+ daily orders?

Accepted Answer

Scale orders schemas by prioritizing read performance:
- Document Structure: Embed order items directly inside the order document (one-to-few relation). Do not store them in separate collections. Embed user summaries (ID, name) to avoid `$lookup` joins on checkout.
- Indexing: Create compound indexes combining customer ID and creation date: `{ customerId: 1, createdAt: -1 }` for dashboard lookups.
- Archival: Use TTL indexes to move completed orders older than a year to cold storage (e.g., MongoDB Atlas Online Archive), keeping active collections lightweight.

Question 39

Explain MongoDB transaction isolation levels, write conflicts, and how the WiredTiger engine handles concurrency.

Accepted Answer

WiredTiger uses multi-version concurrency control (MVCC). It handles transactions using optimistic locking. If transaction A and B modify the same document simultaneously, WiredTiger detects a write conflict. The transaction that commits second fails with a WriteConflict exception. In NestJS/Node APIs, you must implement retry loops to catch write conflict errors and retry transaction execution automatically.

Question 40

Explain how to configure MongoDB security, focusing on RBAC, TLS encryption, and database auditing.

Accepted Answer

Secure MongoDB clusters by:
1. Role-Based Access Control (RBAC): Disable administrative access on public networks, and create restricted users with minimal roles (e.g. `readWrite` on specific databases).
2. Encryption: Force connections to use TLS. Encrypt files stored on disks using Encryption at Rest (AES-256).
3. Auditing: Enable database auditing to log connection events, authentication attempts, and schema modification commands.

Question 41

How would you debug slow MongoDB aggregation pipelines in production under heavy loads?

Accepted Answer

Debug aggregation pipelines using explain: `db.collection.aggregate(pipeline).explain('executionStats')`. Audit pipeline stages:
- match optimization: Ensure the `$match` stage is placed first to filter out documents early, utilizing indexes.
- pipeline projection: Limit returned fields using `$project` before sorting.
- memory limits: WiredTiger limits pipeline stages to 100MB of RAM. If exceeded, enable `{ allowDiskUse: true }` or restructure pipelines.

Question 42

Explain the architecture of MongoDB WiredTiger cache evictions.

Accepted Answer

WiredTiger keeps frequently modified data in memory. If dirty data exceeds thresholds, background threads write pages to disk (eviction), which can cause write latency spikes if I/O is slow.

Question 43

How do you handle schema upgrades on collections with millions of records?

Accepted Answer

Do not run blocking migrations. Instead, design applications to handle dual schemas (defaulting missing fields in code). Update records progressively in background scripts using batch writes with limits.

Question 44

Explain how to trace slow queries using MongoDB Atlas Profiler.

Accepted Answer

Atlas Profiler categorizes queries by execution times. Analyze query shapes that cause high ratio of examined keys to returned documents, indicating missing or un-optimized indexes.

Question 45

How do you configure secondary read routing in replica sets?

Accepted Answer

Set Read Preference in connection strings (e.g. `readPreference=secondaryPreferred`). This routes read queries to secondary replica nodes, keeping the primary node dedicated to write operations.

Question 46

How do you optimize MongoDB storage allocations using compact commands?

Accepted Answer

Deleting documents does not release disk space; WiredTiger retains the empty blocks in its data files. Run `db.runCommand({ compact: 'collectionName' })` to release storage and defragment files.

Question 47

Explain the difference between linearizable and local read concerns.

Accepted Answer

- `local` returns local replica data, which can be rolled back if split.
- `linearizable` waits for majority confirmation, guaranteeing that read data cannot be rolled back, though adding latency.

Question 48

How do you implement client-side field-level encryption in MongoDB?

Accepted Answer

Configure Client-Side Field-Level Encryption (CSFLE). The driver encrypts sensitive fields (like SSNs or credit card numbers) locally before sending them, keeping data encrypted even from database administrators.

Question 49

How do you profile disk write latency spikes in MongoDB?

Accepted Answer

Monitor disk I/O metrics using system tools (like `iostat` or Atlas monitoring dashboards). Check for spikes in WiredTiger log writes to trace writes back to un-buffered collections.

Question 50

Explain how MongoDB handles connection pool sizing.

Accepted Answer

Set `maxPoolSize` in connections (default 100). Clustered servers should monitor active connections: if connection counts hit limits, API requests will queue, increasing latencies.

Question 51

How do you build custom MongoDB storage engines?

Accepted Answer

Implement the pluggable storage engine API. Configure methods to read and write document blocks to custom file structures, compiling the engine into MongoDB source builds.

Question 52

Explain the role of the oplog (operations log) in replica sync.

Accepted Answer

The `oplog` is a capped collection on the primary node that records all writes. Secondary nodes replicate this log asynchronously, applying operations locally to stay in sync with the primary.

Question 53

How do you debug circular index dependencies in MongoDB?

Accepted Answer

Verify that compound indexes do not duplicate prefixes of other compound indexes. Remove redundant indexes to speed up write operations and reduce memory index cache footprints.

MongoDB Interview Questions for 2–5 Years Experience (2026)

What is MongoDB and Why is it Critical in Modern Engineering?

MongoDB Lifecycle Visualizer

Core Architectural Concepts in MongoDB

Document Model Schemas

Indexing (Single/Compound)

Aggregation Pipeline Stages

Replication & Sharding Sets

Mongoose Connection Pools

check_circleWhy Modern Companies Choose MongoDB

lightbulbStrategic Preparation Tips

errorCrucial Mistakes to Avoid

trending_upHiring Trends & Career Outlook (2026)

Basics