Each test is 5 questions with varying difficulty.
AI Prep covers AI Agents, Generative AI, ML Fundamentals, NLP & LLMs and a lot more, with adaptive tests and daily challenges. Fully offline on Android. Free to try, one-time unlock for lifetime access.
MongoDB is the world's most popular document-oriented NoSQL database, and in 2026 it remains the go-to choice for applications that need flexible schema design, horizontal scalability, and expressive query capabilities over JSON-like data. Unlike relational databases, MongoDB stores data as BSON documents within collections, allowing fields to vary between documents and schemas to evolve without costly ALTER TABLE migrations.
In technical interviews, MongoDB questions test a candidate's ability to make schema design decisions that balance query performance against storage efficiency. Junior engineers are expected to understand CRUD operations, basic indexing, and the difference between embedding and referencing documents. Mid-level candidates must reason about compound indexes using the ESR rule, aggregation pipeline stages, and replica set consistency guarantees. Senior candidates are assessed on shard key selection, WiredTiger cache tuning, oplog sizing, and designing schemas that avoid the unbounded array anti-pattern. Roles spanning Data Engineers, Backend Engineers, and AI platform engineers building document stores for agent memory or feature catalogues all require MongoDB proficiency.
MongoDB's flexibility and horizontal scalability make it the database of choice when schema requirements are unclear upfront or change frequently, a common reality for product teams iterating rapidly. In e-commerce, it powers product catalogues with varied attribute sets without schema locks. In fintech, it stores complex nested transaction documents that would require many JOIN tables in a relational model. In AI engineering, it serves as the backing store for vector metadata, agent conversation history, and unstructured prompt logs.
From a performance perspective, MongoDB's WiredTiger storage engine with document-level locking eliminates the table-level locking bottleneck of older MySQL MyISAM. Its native aggregation pipeline handles complex transformations server-side, reducing round trips. In 2026, as AI-generated content and IoT sensor data create unprecedented volumes of semi-structured data, MongoDB's schema-less model and Change Streams for CDC pipelines have become increasingly valuable in event-driven architectures.
As a high-signal interview topic, MongoDB questions reveal whether a candidate understands the tradeoffs inherent in document databases, specifically the risk of denormalization leading to data inconsistency, and the danger of choosing a poor shard key that creates hotspots. A strong candidate explains not just how to use MongoDB but when NOT to use it, citing scenarios where strong ACID transactions across multiple entities make PostgreSQL the more appropriate choice.
MongoDB's architecture is designed for distributed scale. It uses a primary-secondary replication model for high availability and a sharding model for horizontal scalability. Data is stored in BSON format on disk via the WiredTiger engine, which manages a memory cache for frequently accessed data.
A client sends a request to a Mongod (or Mongos). The engine checks the WiredTiger cache; if the data is missing, it reads from disk. Writes are recorded in the Oplog and Journal before being asynchronously replicated to secondary nodes.
[Client Application]
↓
[Mongos Router (if sharded)]
↓
[Config Servers (Metadata)]
↓
[Shard A (Replica Set)] [Shard B (Replica Set)]
↓ ↓
[Primary Node] [Primary Node]
↓ ↓
[Secondary Nodes] [Secondary Nodes]
↓ ↓
[WiredTiger Engine] [WiredTiger Engine]
↓ ↓
[Data Files / Journal] [Data Files / Journal]Grouping related data points (like time-series data) into a single document to reduce the number of documents and index entries.
Trade-offs: Reduces index size but can lead to very large documents if buckets are not sized correctly.
Storing a subset of fields from a related document directly in the primary document to avoid $lookup joins.
Trade-offs: Improves read performance but requires application logic to keep data synchronized (denormalization).
Using an array of key-value pairs to store varied attributes, allowing for a single index to cover many fields.
Trade-offs: Simplifies indexing for unpredictable schemas but makes queries slightly more complex.
| Reliability | Achieved through Replica Sets with a minimum of three nodes. Use 'w: majority' and 'j: true' to ensure writes are committed to the journal and replicated. |
| Scalability | Horizontal scaling is handled via Sharding. Vertical scaling involves increasing RAM to ensure the 'working set' fits within the WiredTiger cache. |
| Performance | Optimized by ensuring all queries are 'covered' by indexes. Use the 'explain()' plan to identify and eliminate 'COLLSCAN' operations. |
| Cost | Managed in Atlas by using auto-scaling clusters and 'Online Archive' to move cold data to S3, reducing expensive SSD storage costs. |
| Security | Requires enabling RBAC (Role-Based Access Control), TLS/SSL for encryption in transit, and 'Encryption at Rest' for data files. |
| Monitoring | Key metrics include 'Document Locking', 'Cache Eviction Rates', 'Oplog Window', and 'Replication Lag'. Alert when lag exceeds 10 seconds. |
Embedding is preferred for 'one-to-few' relationships where data is frequently read together, providing high performance. Referencing is better for 'one-to-many' or 'many-to-many' relationships to avoid the 16MB document size limit and reduce data duplication. In 2026, the decision is driven by access patterns: if you need to query the related data independently, use a reference; if it only exists in the context of the parent, embed it.
Since version 4.0, MongoDB supports multi-document ACID transactions across replica sets, and since 4.2, across sharded clusters. These transactions use snapshot isolation and provide all-or-nothing execution. However, they carry a performance overhead and should only be used when operations across multiple documents must be atomic, rather than as a substitute for proper document modeling.
The ESR rule stands for Equality, Sort, Range. It dictates the order of fields in a compound index for maximum efficiency. Equality fields (e.g., status: 'active') should come first, followed by Sort fields (e.g., date: -1), and finally Range fields (e.g., price: { $gt: 100 }). Following this rule ensures the index can satisfy the filter and the sort without an expensive in-memory sort.
Ranged sharding partitions data based on continuous ranges of values, which is excellent for range-based queries but can lead to 'hot shards' if data is inserted sequentially. Hashed sharding computes a hash of the shard key value to distribute data evenly across shards, preventing hot spots but making range queries inefficient as they must be broadcast to all shards.
Replication lag occurs when secondaries cannot keep up with the primary's write volume. Troubleshoot by checking network latency, disk I/O on secondaries, and the size of the Oplog. If the Oplog is too small, secondaries may fall off the 'Oplog window' and require a full resync. Use 'rs.printSlaveReplicationInfo()' to monitor lag in real-time.
While MongoDB does not enforce a schema at the storage level, production applications almost always use 'Schema Validation' via JSON Schema. This allows you to enforce data types, required fields, and value ranges at the database level. Calling it 'flexible schema' is more accurate than 'schemaless,' as it allows for evolution while maintaining data integrity.
The WiredTiger cache stores frequently accessed data and indexes in RAM to minimize disk I/O. By default, it takes 50% of (RAM - 1GB). If the 'working set' (the data your app actively uses) exceeds this cache size, performance drops significantly as the engine must constantly swap data from disk. Monitoring the 'cache eviction' rate is key to performance tuning.
If the primary node becomes unreachable, the remaining secondary nodes hold an election using the Raft consensus protocol. A node must receive a majority of votes to become the new primary. This process usually takes less than 12 seconds. During this time, the replica set cannot accept writes, but can still serve reads if the client's read preference allows it.
Change Streams allow applications to listen for real-time data changes (inserts, updates, deletes) in a collection, database, or cluster without tailing the oplog manually. They are commonly used for building reactive UIs, triggering serverless functions, or synchronizing data with external systems like Elasticsearch or a cache.
GridFS is used for storing and retrieving files that exceed the 16MB BSON document limit, such as large images, videos, or PDFs. It works by splitting the file into smaller chunks and storing them in two collections: 'fs.files' (metadata) and 'fs.chunks' (binary data). It is useful when you want your file storage to stay synced with your database backups.
AI Prep covers AI Agents, Generative AI, ML Fundamentals, NLP & LLMs and a lot more, with adaptive tests and daily challenges. Fully offline on Android. Free to try, one-time unlock for lifetime access.