MongoDB is the most popular NoSQL document database. These MongoDB interview questions cover documents, collections and CRUD for freshers, then schema design, indexing, the aggregation pipeline, transactions, replica sets and sharding for experienced developers.
30 questions · Updated
Fundamentals, definitions and simple scenarios. Good for freshers and warm-ups.
MongoDB is a NoSQL database that stores data as flexible JSON-like documents (BSON) in collections, instead of rows in tables with a fixed schema.
Related data is often embedded in one document, reducing joins.
It scales horizontally with sharding.
Relational databases are better for highly relational data needing complex joins and strict constraints.
Every document has a unique _id field that acts as the primary key. If you do not provide one, MongoDB generates an ObjectId, a 12-byte value containing a timestamp, a random value and a counter, so IDs are roughly ordered by creation time.
insertOne and insertMany create documents; find and findOne read them with filters such as { age: { $gt: 25 } } and projections; updateOne, updateMany and replaceOne change documents using operators such as $set, $inc and $push; deleteOne and deleteMany remove them.
BSON (Binary JSON) is the binary format MongoDB uses to store documents.
It is faster to scan than text JSON and supports extra types such as ObjectId, Date, Decimal128 for exact money values, 32- and 64-bit integers, binary data and regular expressions.
Drivers convert between BSON and your language's objects automatically.
Comparison operators such as $eq, $ne, $gt, $gte, $lt, $lte, $in and $nin; logical operators $and, $or, $not and $nor; element operators $exists and $type; $regex for patterns; and array operators $all, $size and $elemMatch. For example, db.users.find({ age: { $gte: 18 }, city: { $in: ["Pune", "Delhi"] } }).
$set sets fields, $unset removes them, $inc increments numbers, $push adds to an array, $addToSet adds only if the value is not already present, $pull removes matching array items and $rename renames a field. With the option { upsert: true }, an update inserts a new document if none matches the filter.
The second argument to find is a projection that includes or excludes fields, such as { name: 1, email: 1, _id: 0 }. sort({ createdAt: -1 }) sorts descending, and limit and skip paginate. Large skip values are slow, so for big collections paginate with a range on an indexed field, such as createdAt less than the last value seen.
Mongoose is a popular library for MongoDB in Node.js that adds schemas, data types, validation, default values, middleware hooks (such as hashing a password before saving), virtual fields, population of references, and model methods. It gives structure to MongoDB's flexible documents, which helps keep data consistent in applications.
Atlas is MongoDB's managed cloud database service on AWS, Azure and Google Cloud.
It handles provisioning, replication, backups, scaling, upgrades and monitoring, and adds features such as Atlas Search (full-text search), Vector Search, Charts and online archive.
It has a free tier, which is popular for learning and small projects.
Yes.
Although documents are flexible, a collection can have a validator with a $jsonSchema that defines required fields, types, allowed values and patterns. validationLevel and validationAction decide whether invalid documents are rejected or just logged.
Combined with application-level schemas such as Mongoose, this keeps data clean.
A query like { "items.sku": "A1", "items.qty": { $gt: 5 } } can match a document where one item has the SKU and a different item has the quantity. $elemMatch requires both conditions on the same array element: { items: { $elemMatch: { sku: "A1", qty: { $gt: 5 } } } }. The positional $ operator updates the matched element.
Applied problems, trade-offs and questions about your own projects.
I embed when data is accessed together and belongs to one parent, such as order items inside an order or an address inside a user, which allows one-read access.
I reference with IDs when related data is large, grows without limit (such as comments on a viral post), is shared by many documents or changes independently.
Documents have a 16 MB size limit.
The aggregation pipeline processes documents through stages, each transforming the results: $match filters, $group groups and calculates totals, $project reshapes fields, $sort, $limit, $lookup joins another collection, $unwind expands arrays and $facet runs several pipelines at once. Putting $match early lets indexes be used and reduces work.
Without an index, MongoDB scans every document in the collection. Indexes are B-trees on fields: single-field, compound (where field order follows the equality, sort, range rule), multikey for arrays, text, geospatial, TTL indexes that delete documents after a time, and unique and partial indexes. explain("executionStats") shows whether a query uses an index.
Yes.
Single-document operations have always been atomic, which is why embedding related data is useful.
Since version 4.0 MongoDB supports multi-document ACID transactions on replica sets, and on sharded clusters since 4.2.
Transactions have performance costs, so a good schema should keep most operations to one document.
$lookup is an aggregation stage that performs a left outer join with another collection, adding matching documents as an array field, and can use a pipeline for complex conditions.
It is useful but slower than embedded data, especially without an index on the foreign field, and it is limited across sharded collections.
Frequent heavy lookups suggest the schema should embed or duplicate some data.
Write concern sets how many replica set members must confirm a write, such as w: "majority" for durability.
Read concern sets the consistency of data read, such as "majority" for data that cannot be rolled back.
Read preference chooses which members serve reads: primary (the default, most current), or secondaries for scaling reads when slightly stale data is acceptable.
Order the fields in a compound index as Equality, then Sort, then Range.
Fields tested for exact matches come first, then fields used for sorting, then fields with range conditions such as $gt or $lt.
Following this rule lets one index both filter efficiently and return results already sorted, avoiding slow in-memory sorts.
A text index supports basic keyword search with $text and relevance scores, but only one text index per collection is allowed and features are limited.
Atlas Search, built on Apache Lucene, provides proper full-text search with fuzzy matching, autocomplete, facets and relevance tuning through the $search aggregation stage.
Regular expressions without a prefix cannot use indexes efficiently.
Change streams let applications subscribe to real-time changes (inserts, updates, deletes) on a collection, database or whole deployment, using the replica set's operation log.
They are used to sync data to search engines or caches, trigger notifications and build event-driven systems.
A resume token lets a consumer continue from where it stopped after a restart.
GridFS stores files larger than the 16 MB document limit by splitting them into chunks stored in one collection, with metadata in another.
It lets you keep files in MongoDB with replication and backups.
For most applications, object storage such as S3 with just the file URL saved in MongoDB is cheaper and faster.
Extended reference (copy frequently needed fields from a related document to avoid lookups), subset (embed only recent or top items, such as the latest 10 reviews), computed (store pre-calculated totals), bucket (group time-series readings into one document per hour), outlier (handle rare huge documents separately), and schema versioning (store a version field to migrate documents gradually).
System design, deep internals, leadership and tough follow-ups.
A replica set is a group of MongoDB servers holding the same data: one primary that accepts writes and secondaries that replicate its operation log.
If the primary fails, the members elect a new primary automatically.
Write concern controls how many members must confirm a write, and read preference allows reading from secondaries.
Sharding distributes data across several replica sets (shards) for horizontal scaling.
A good shard key has high cardinality, distributes writes evenly and matches common query patterns so queries go to one shard.
A monotonically increasing key such as a timestamp sends all new writes to one shard; hashed sharding or a compound key avoids this.
Shard keys can be refined but are hard to change.
I design around access patterns: products with embedded variants and attributes; orders that embed a snapshot of item details, prices and shipping address so history does not change when products do; users with embedded addresses; and reviews in a separate collection referencing the product, with summary fields like average rating stored on the product. I add indexes for the main queries such as category and price.
Run explain("executionStats") and check the winning plan: IXSCAN means an index was used and COLLSCAN means a full collection scan.
Compare totalDocsExamined and totalKeysExamined with nReturned; ideally they are close.
A covered query, where all fields are in the index and _id is excluded, reads no documents at all.
The database profiler and Atlas Performance Advisor find slow queries and suggest indexes.
Because documents in one collection can have different shapes, add a schemaVersion field and make the application handle both old and new versions.
Migrate documents lazily when they are read or updated, or in background batches, and remove support for old versions once all documents are migrated.
Validators can be updated to require the new structure for new writes.
Time series collections, added in MongoDB 5.0, are optimised for measurements over time such as sensor readings, metrics and stock prices.
You declare a timeField and metaField, and MongoDB stores data in compressed, column-like buckets automatically, which greatly reduces storage and speeds up time-based queries.
Documents can expire automatically with expireAfterSeconds.
Atlas Vector Search stores embeddings, arrays of numbers produced by AI models, inside documents and indexes them for approximate nearest-neighbour search. The $vectorSearch aggregation stage finds documents with embeddings most similar to a query embedding, optionally filtered by other fields, which powers semantic search and retrieval-augmented generation alongside normal application data.
When data is highly relational with many-to-many relationships and complex joins, such as accounting or ERP systems; when you need complex multi-table transactions as the main workload; when strict schemas and constraints are essential; or for heavy ad hoc analytics, where a relational database or data warehouse fits better. MongoDB is strong for flexible, document-shaped data accessed by key or simple queries.
See all Database Engineer interview questions, covering SQL, MySQL, PostgreSQL, Oracle, SQL Server and more.