MongoDB Interview Questions

A relational database genuinely enforces a fixed schema, structured tables, rows, and columns, related through foreign keys. MongoDB stores data as genuinely flexible documents, where different documents in the exact same collection can genuinely have different fields, without requiring a genuinely rigid, predefined schema.

A document is the genuine basic unit of data in MongoDB, stored in a format called BSON, a binary version of JSON, containing a genuine set of field-value pairs, conceptually genuinely similar to a single row in a relational database table.

A collection is a genuine grouping of documents, conceptually similar to a table in a relational database. Unlike a genuine table, though, a collection doesn't enforce that every document within it genuinely share the exact same fields or structure.

Every document genuinely has a unique _id field, automatically genuinely generated by MongoDB if you don't explicitly provide one yourself, serving as that document's genuinely primary identifier within its collection, similar in role to a primary key in a relational database.

It lets an application's data structure genuinely evolve over time without requiring a formal schema migration for every single change, and it fits data that's genuinely naturally hierarchical or nested, like an order with several line items, without needing to genuinely split that data across several separate related tables.

Horizontal scalability means adding more servers to a cluster to handle more data or traffic, rather than relying entirely on making one single server bigger and more powerful. It matters because there's a real, practical ceiling on how large a single server can get, while adding more machines to a cluster can, in principle, keep scaling well beyond what any one machine could handle alone.

db.users.insertOne({ name: 'Anu', age: 25 }) genuinely inserts a single new document into the users collection. insertMany() genuinely inserts an array of several documents together in one single operation.

db.users.find({ age: 25 }) genuinely returns every document in the users collection where the age field actually equals 25. Calling find() with genuinely no argument at all returns every single document in that collection.

find() returns a genuine cursor over every matching document. findOne() returns genuinely just the single first matching document directly, or null if genuinely nothing actually matches, without needing to iterate over a cursor at all.

db.users.updateOne({ name: 'Anu' }, { $set: { age: 26 } }) genuinely finds the first document matching the given filter and updates its age field to 26, using the $set operator to genuinely modify just that specific field without touching any other genuine field on the document.

db.users.deleteOne({ name: 'Anu' }) genuinely removes the first document matching the given filter. deleteMany() genuinely removes every document matching the given filter, rather than stopping after just the first one.

updateOne() genuinely modifies only the first document matching the given filter. updateMany() genuinely modifies every single document matching that same filter, applying the exact same update to each one.

Embedding stores genuinely related data directly nested within the exact same document, useful when that related data is genuinely always accessed together. Referencing stores genuinely related data in a separate document, linked by an ID, similar in spirit to a foreign key in a relational database, useful when that related data is genuinely shared or accessed independently.

Embedding fits data with a genuinely clear, one-to-few relationship that's almost always accessed together, like an order and its own specific line items, since it lets you genuinely retrieve everything needed in a single query without an additional lookup.

Referencing fits data that's genuinely large, frequently updated independently, or shared across many other documents, like a single author record referenced by many separate blog post documents, where embedding the author's full data into every single post would genuinely duplicate it wastefully.

Denormalization means genuinely duplicating some data across documents rather than storing it in exactly one place. It's more common in MongoDB because joining data across genuinely separate collections is less efficient than in a relational database, so a small amount of genuine duplication often improves read performance meaningfully.

Update every copy of the duplicated value at write time, typically inside the same application code path that changes the original source of truth, and accept a brief window of eventual consistency between the update to the source and every duplicated copy actually catching up, rather than trying to enforce perfect, instantaneous synchronization across all of them.

Schema validation lets you genuinely define rules a document must actually satisfy before MongoDB accepts it, like requiring a specific field or a specific data type. It's used to genuinely prevent an application bug from accidentally inserting malformed, inconsistent data, even though MongoDB itself doesn't genuinely require a rigid schema by default.

Over-normalizing data into many genuinely small, separate collections the way you would in a relational database, requiring many separate lookups to actually reconstruct a single logical object, rather than genuinely embedding closely-related data together the way MongoDB's own document model is actually designed to support well.

An index is a genuinely separate data structure letting MongoDB find matching documents quickly, without genuinely scanning every single document in a collection one by one. It works much like a book's own index, letting you jump directly to relevant data instead of reading through everything.

db.users.createIndex({ email: 1 }) genuinely creates an ascending index on the email field, letting a query filtering on that field actually run much faster than it would need to scan the entire collection.

Every collection genuinely has a default index on its own _id field, automatically created when the collection is genuinely first created, ensuring lookups by _id are always genuinely fast without needing any additional, explicit index creation.

An ascending index (specified with 1) stores genuine values in increasing order. A descending index (specified with -1) stores them in genuinely decreasing order. For a genuinely single-field index used alone, the direction genuinely doesn't matter much for query performance, but it genuinely matters more for a compound index or a sort operation.

Appending .explain() to a query, like db.users.find({ email: 'test@example.com' }).explain(), shows the genuine execution plan MongoDB actually used, revealing whether it performed an efficient index scan or a genuinely slower full collection scan instead.

Every index genuinely has to be updated whenever a document is inserted, updated, or deleted, so more indexes mean more genuine overhead on every single write operation. An index also genuinely consumes real storage space, so indexing every field just in case tends to genuinely slow down writes without a matching, real benefit.

$eq for equal to. $gt and $gte for greater than (or equal to). $lt and $lte for less than (or equal to). $ne for not equal to. db.users.find({ age: { $gt: 18 } }) genuinely finds every user older than 18.

$and genuinely requires every specified condition to actually be true for a document to genuinely match. $or genuinely requires at least one of the specified conditions to actually be true, matching a document that genuinely satisfies any single one of them.

$in matches a document where a specific field's value genuinely equals any one value within a given array, like db.users.find({ status: { $in: ['active', 'pending'] } }), matching a document whose status is genuinely either active or pending.

db.users.find({ middleName: { $exists: false } }) genuinely returns every document where the middleName field is actually absent entirely, distinct from a document where that field genuinely exists but happens to hold a null value.

$regex matches a genuine string field against a regular expression pattern, letting you actually search for a document where a text field genuinely contains, starts with, or matches a specific pattern, rather than requiring an exact, complete match.

db.users.find().sort({ age: -1 }).limit(10) genuinely returns the ten oldest users, sorting the matching documents in descending order by age and returning only the genuinely first ten results from that sorted set.

The Aggregation Framework processes documents through a genuine series of stages, called a pipeline, each stage transforming the data in some way, filtering, grouping, reshaping, before passing the actual result along to the genuinely next stage, ultimately producing a computed, summarized result.

$match filters documents based on a genuine condition, conceptually similar to a query's filter, letting only documents genuinely satisfying that condition actually continue on to the genuinely next stage of the pipeline.

$group groups documents by a genuinely specified field and computes an aggregate value for each group, like a total or an average, similar in spirit to a GROUP BY clause combined with an aggregate function in SQL.

$project reshapes each document, genuinely including, excluding, or computing a new field, letting you actually control exactly which fields appear in the pipeline's own output, rather than passing every original field along unchanged.

db.orders.aggregate([{ $group: { _id: '$category', total: { $sum: '$amount' } } }]) genuinely groups every order document by its category field and sums the amount field within each group, producing one genuine result document per distinct category.

bulkWrite() genuinely accepts an array of several operations, inserts, updates, deletes, executed together in one single, efficient request, rather than making a genuinely separate round trip to the database for each individual operation.

$inc genuinely increments a numeric field by a specified amount. $push genuinely adds an element to an array field. $pull genuinely removes an element matching a condition from an array field. $unset genuinely removes a field entirely from the document.

db.users.updateOne({ _id: id }, { $push: { tags: 'vip' } }) genuinely adds the value vip to the end of the tags array field on the matching document, without needing to genuinely read the entire array first and rewrite it back with the new value appended.

$set genuinely applies its specified field updates whether the operation actually results in an update or an insert. $setOnInsert genuinely applies its specified field values only if the operation actually results in a genuinely new document being inserted, letting you set an initial value, like a creation timestamp, only once.

$lookup performs a genuine left outer join, pulling in related documents from a genuinely separate collection based on a matching field, similar in spirit to a JOIN in SQL, letting you actually combine data spread across two collections within one single aggregation pipeline.

{ $group: { _id: '$category', count: { $sum: 1 }, avgPrice: { $avg: '$price' } } } genuinely computes both a count and an average price within the exact same grouping operation, rather than needing to run genuinely two separate aggregation pipelines.

$unwind deconstructs an array field, genuinely producing one separate output document for each individual element in that array, which is genuinely useful before a subsequent $group or $match stage that needs to actually operate on each individual array element separately.

Placing a $match stage as genuinely early as possible in the pipeline, before an expensive stage like $group or $lookup, reduces the number of documents that actually need to be processed by every subsequent stage, meaningfully improving overall genuine pipeline performance.

$facet runs genuinely multiple separate aggregation pipelines against the exact same input documents simultaneously, combining their genuinely separate results together into one single output document. It solves the genuine problem of needing several genuinely different aggregated views of the exact same data, like a paginated result alongside a genuine total count, without running genuinely separate queries.

A compound index spans genuinely multiple fields together, and the genuine order those fields are listed in matters significantly, following what's called the ESR (Equality, Sort, Range) rule, since a compound index can efficiently support a query genuinely filtering on a prefix of its own fields, but not genuinely arbitrary combinations.

A multikey index is genuinely automatically created when you index a field that actually holds an array, indexing each genuine element of that array separately, letting a query genuinely find a document based on any single value actually contained within that array field.

A text index supports genuine full-text search across a string field, letting you actually search for a word or phrase within that field's content rather than requiring an exact match, similar in spirit to what SOSL provides in a genuinely different database context.

A TTL index automatically genuinely deletes a document after a specified amount of time has passed since a genuine date field's own value. A genuinely common use case is automatically expiring session data or a temporary token document after it's no longer genuinely needed.

The explain() output's winningPlan section shows the actual genuine stage used, IXSCAN indicating an efficient index scan was actually used, while COLLSCAN indicates MongoDB genuinely had to scan every single document in the collection instead, which is genuinely the signal to actually look at adding an appropriate index.

The Bucket Pattern groups genuinely several related, time-series data points into one single document, like grouping a sensor's readings for an entire hour into one document rather than a genuinely separate document per individual reading. It reduces the genuine total number of documents and index entries needed for a very high-volume, time-series workload.

The Subset Pattern embeds only the genuinely most relevant, frequently accessed portion of a large related dataset directly, like a product's most recent few reviews, while keeping the genuinely full, complete dataset in a separate collection. It's used when embedding an entire, potentially very large related dataset would make a document genuinely too large.

A single document is genuinely limited to 16 megabytes. This limit genuinely influences schema design because embedding a genuinely unbounded, ever-growing array of related data, like every single comment on a genuinely popular post, could eventually exceed that limit, pushing the design toward referencing instead once that growth is genuinely unbounded.

I'd weigh how genuinely bounded the many side actually is, a bounded, small set favors embedding, and how often that related data is genuinely accessed together versus independently, since data almost always accessed together favors embedding, while data genuinely accessed and updated independently favors referencing instead.

A replica set maintains genuinely multiple copies of the same data across separate servers, providing automatic failover if the genuine primary server becomes unavailable, and improving read availability. It solves the genuine problem of a single database server being a genuine single point of failure.

The primary node genuinely receives all write operations by default. Secondary nodes genuinely replicate data from the primary and can genuinely serve read operations if configured to do so, but don't genuinely accept a direct write themselves under normal, standard operating conditions.

An election genuinely happens when the current primary becomes unavailable, and the remaining eligible secondary nodes genuinely vote among themselves to actually elect a new primary automatically, restoring the replica set's genuine ability to accept writes without requiring a person to manually intervene.

Read preference determines which specific node type a query is actually directed to. Reading from a secondary can genuinely reduce load on the primary for a read-heavy workload, though it comes with the genuine trade-off of potentially reading slightly stale data, since replication to a secondary isn't genuinely instantaneous.

The shard key determines which specific shard a given document actually lives on. A poorly chosen shard key can lead to genuinely uneven distribution, some shards ending up with dramatically more data or traffic than others, largely defeating the entire genuine purpose of sharding in the first place.

A range-based shard key genuinely distributes documents based on a specific range of shard key values, which supports efficient range queries but risks genuinely uneven distribution if writes concentrate around a genuinely narrow, sequentially increasing range. A hashed shard key genuinely distributes documents more evenly by hashing the key's value, at the cost of no longer efficiently supporting a genuine range query on that same field.

mongos acts as a genuine query router, sitting between an application and the actual sharded cluster, routing each incoming query to the genuinely appropriate shard (or shards) based on the shard key, so an application can genuinely interact with the cluster as if it were one single, unified database.

I'd look at the actual, genuine bottleneck, is it a storage capacity ceiling, a write throughput ceiling, or genuinely both, that a single server, even one genuinely upgraded further, could no longer reasonably handle. Sharding adds genuine real operational complexity, so it's worth adopting only once vertical scaling genuinely, actually hits a real, concrete limit.

Changing a shard key after the fact is genuinely difficult and disruptive, often requiring a genuinely significant data migration or, in some cases, a complete re-architecture of the sharded cluster. This is exactly why choosing a genuinely well-considered shard key upfront, based on actual real access patterns, matters so much before sharding is actually deployed.

The database profiler, or simply checking explain() on the specific slow query, reveals whether it's genuinely using an appropriate index or performing a genuinely expensive full collection scan, which is usually the actual, real starting point before genuinely guessing at other possible causes.

The profiler captures genuinely detailed information about database operations, including their actual execution time and the genuine query plan used, letting you actually identify which specific operations are genuinely running slowly in a production system without needing to manually check every single query by hand.

Ensure a $match stage genuinely appears as early as possible in the pipeline to reduce the actual number of documents flowing through genuinely later, more expensive stages, and check whether that early $match can genuinely make use of an existing index rather than requiring a full collection scan.

The working set is the genuine portion of data and indexes actively being accessed and ideally held in memory. Performance can genuinely degrade significantly once the working set no longer fits comfortably in available RAM, forcing MongoDB to genuinely read frequently-accessed data from slower disk storage instead.

A covered query is one where genuinely every field the query needs, both for filtering and for the actual returned result, is entirely present within the index itself, letting MongoDB satisfy the query directly from the index without ever needing to genuinely fetch the actual full document from disk at all.

Before multi-document transaction support genuinely existed, a single document's own update was always genuinely atomic on its own, so embedding related data into one document let an application genuinely achieve atomicity without an explicit transaction. Transactions now genuinely provide that same atomicity across separate documents too, though they still carry genuine additional performance overhead worth being aware of.

A Change Stream lets an application genuinely subscribe to real-time notifications about data changes happening in a collection, enabling a genuinely event-driven architecture where another system can immediately, automatically react to a MongoDB write, rather than relying on genuinely slower, periodic polling to detect a change.

Write concern determines how many replica set members must genuinely acknowledge a write before it's actually considered successful, trading genuine durability against latency. Read concern determines the genuine consistency guarantee a read operation actually requires, like whether it must genuinely reflect only data that's actually been acknowledged by a majority of replica set members.

The Bucket Pattern, grouping genuinely several time-series readings into one document rather than a genuinely separate document per reading, meaningfully reduces the total document and index-entry count, and a genuinely well-chosen shard key distributes that write load evenly across multiple shards rather than concentrating it on just one.

WiredTiger is MongoDB's genuinely current default storage engine, providing document-level locking (rather than a genuinely coarser, collection-level lock an older engine used), and built-in compression, both meaningfully improving write concurrency and genuinely reducing the actual storage footprint compared to that older approach.

Identify genuinely older, less frequently accessed data and move it to a genuinely separate, cheaper archive collection or an entirely different storage tier, keeping the genuinely active, frequently-queried collection lean and fast, while still preserving the archived historical data for compliance or occasional reference.

A capped collection has a genuinely fixed maximum size, and once it's full, MongoDB automatically overwrites the oldest documents to make room for new ones, maintaining insertion order without requiring an explicit index for that ordering. A genuinely common use case is storing application logs where only recent entries actually matter and older ones can safely be discarded automatically.

mongodump creates a genuine logical, BSON-based backup of the data. Filesystem-level snapshots capture the genuine underlying storage files directly, generally faster for a genuinely large dataset. A managed service, like MongoDB Atlas, typically provides genuinely automated, continuous backup handling this entirely for you.

A logical backup, like mongodump, reads and exports the genuine data itself, portable across different MongoDB versions but genuinely slower for a very large dataset. A filesystem snapshot captures the genuine underlying storage files directly, much faster to actually create and restore, but genuinely tied more closely to the specific storage system and MongoDB version it was actually taken from.

Track replication lag, connection count, query execution time, and disk and memory usage over time, alerting on meaningful deviation from an established, normal baseline. Replication lag genuinely matters specifically because a secondary falling significantly behind the primary can genuinely serve noticeably stale data if reads are actually directed to it.

Replication lag is the genuine delay between a write actually happening on the primary and that same write actually being applied to a secondary node. It matters because a genuinely significant lag means a read directed to that secondary could return meaningfully outdated data, and it also genuinely affects how quickly a secondary could actually take over if the primary fails.

I'd monitor genuine storage growth and query performance trends proactively, load test with a genuinely realistic future data volume, and decide well ahead of time whether vertical scaling, adding read replicas, or moving to a genuinely sharded architecture is the appropriate path, rather than waiting until performance has already actually started degrading for real users.

Given MongoDB's genuinely flexible schema, you'd typically write application code to genuinely handle both the old and new document shapes gracefully, backfilling the new field gradually in the background through a batched update script, rather than requiring one single, disruptive, all-at-once migration the way a rigid relational schema change genuinely would.

I'd run it incrementally, keeping both systems genuinely running in parallel during a transition period, validating that data and query results genuinely match between the two, and migrating one bounded, well-understood piece of functionality at a time rather than attempting a genuinely large, disruptive, all-at-once cutover.

I check whether the genuine embedding versus referencing decisions fit the actual, real access patterns rather than following a rigid, one-size-fits-all rule, whether appropriate indexes are already planned for the specific queries the application will actually run most frequently, and whether the design will genuinely hold up as data volume grows substantially larger over time.

Automate what can genuinely be automated, schema validation rules and required-index checks enforced directly in a deployment pipeline, so standards aren't purely a matter of individual opinion. For conventions that genuinely resist full automation, I'd document the handful of decisions that actually matter most, along with the real reasoning behind each one.

I'd weigh the actual, concrete growth trajectory and the real cost of sharding's own added operational complexity against how much further vertical scaling on a single, more powerful replica set could genuinely still take the deployment. Sharding is worth it once vertical scaling genuinely, actually hits a real, concrete ceiling, not preemptively.

I'd check whether the actual test data volume genuinely resembles production, since a query that's fast on a small test dataset can genuinely become dramatically slower once the real, much larger production data volume is genuinely involved. I'd also look specifically at replication lag and connection pool exhaustion under real concurrent load.

Track query latency, replication lag, connection count, and disk and memory usage over time, alerting on meaningful deviation from an established, normal baseline rather than relying only on a hard, static threshold. A slowly growing replication lag trend is often a genuine early warning sign well before it actually causes a real, tangible problem.

Treat the collection's genuine document shape as a contract with every consumer, even though MongoDB itself doesn't enforce a rigid schema. Adding a genuinely new, optional field is generally safe. Renaming or removing an existing field needs a documented migration path, with application code genuinely handling both the old and new shapes during a transition period.

I'd check first whether the underlying collection's data volume or actual document shape has genuinely changed recently, and whether an existing index somehow genuinely became less effective, since data distribution shifting can sometimes genuinely change how well a previously well-performing index actually serves a specific query.

Start from actual load testing against a realistically scaled-up dataset and traffic pattern, rather than a rough guess based purely on the application's current traffic numbers. I'd specifically identify whether the coming bottleneck is genuinely likely to be read capacity, write throughput, or storage, since each of those calls for a meaningfully different scaling response.

This is a judgment question interviewers use to see how you reason under genuine uncertainty, not to test a specific textbook fact. A strong answer names the actual constraint that forced the decision, the realistic options that were genuinely on the table, why you picked one knowing it wasn't guaranteed to be right, and what you'd do differently with what you know now.

I'd walk through one of their actual queries together against a realistically large dataset, showing the explain() output directly and pointing out concretely where the real cost is genuinely coming from, rather than just telling them the query is inefficient in the abstract. Seeing their own query's actual plan tends to shift how they write the next one far more effectively.

I wouldn't lead with schema design theory in the abstract. I'd point to a specific, real, already-experienced performance problem caused by requiring genuinely several separate lookups to reconstruct one logical object, and show concretely how embedding that closely-related data would have genuinely prevented that exact same specific problem.

I'd bring the actual query patterns and real, measured performance data behind my position, rather than a general, unsubstantiated preference for one particular approach. Most disagreements like this genuinely resolve once both sides are looking at the exact same concrete numbers together, instead of arguing from differing, unstated assumptions about how the data is actually being used.

I'd translate the work into terms leadership already tracks: the cost of a specific past outage or slowdown that traced back to the current setup, and what continued growth in traffic or data volume would do to that same problem if left unaddressed. Framed as risk reduction with a concrete, already-incurred cost attached, it competes far better for prioritization than framed as a purely technical improvement.