Question 1

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 2

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

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 12

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 13

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 14

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 15

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 16

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 17

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 18

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 19

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 20

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 21

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 22

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 23

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 24

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 25

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 26

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 27

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 28

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 29

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 30

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 31

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 32

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 33

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.

Senior MongoDB Interview Questions (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)

Architecture