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.

MongoDB Interview Questions for Freshers (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