MongoDB Interview Questions India 2026: Document Model, Aggregation Pipeline, and Sharding

MongoDB stores data as documents rather than rows in tables. Understanding the document model and BSON is the foundation for MongoDB interviews.

Document model vs relational:

1. MongoDB stores data as BSON documents (Binary JSON) in collections
2. Collections are analogous to tables; documents are analogous to rows
3. Each document can have a different structure (schema-flexible); there is no enforced schema by default
4. Documents can embed related data (embedded documents and arrays) instead of using joins
5. Embedding vs referencing: embed when data is always accessed together and the embedded data is not too large; reference (store ObjectId of the related document) when data is accessed independently or shared by many documents

BSON (Binary JSON):

1. BSON is the binary serialisation format MongoDB uses to store and transfer documents
2. BSON supports types not in JSON: ObjectId (12-byte unique ID: 4 bytes timestamp + 5 bytes random + 3 bytes counter), Date, Binary, Decimal128, Int32, Int64, Boolean, Null
3. Every MongoDB document has a required _id field; if not provided, MongoDB generates an ObjectId automatically

CRUD operations:

1. insertOne({ name: 'Alice', age: 30 }) — insert a single document
2. insertMany([{...}, {...}]) — insert multiple documents
3. findOne({ age: { $gt: 25 } }) — find the first document where age > 25
4. find({ status: 'active' }).sort({ name: 1 }).limit(10) — find with sort and limit
5. Query operators: $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $and, $or, $nor, $not, $regex, $exists
6. updateOne({ _id: id }, { $set: { status: 'inactive' } }) — update one field
7. updateMany({ status: 'pending' }, { $set: { status: 'active' } }) — update multiple documents
8. $set (set fields), $unset (remove fields), $push (add to array), $pull (remove from array), $inc (increment), $addToSet (add to array if not present)
9. deleteOne({ _id: id }) — delete one document
10. deleteMany({ createdAt: { $lt: cutoffDate } }) — delete multiple documents
11. replaceOne — replaces the entire document except _id
12. Upsert: { upsert: true } in update options — insert if no document matches the filter

The aggregation pipeline is MongoDB's most powerful data transformation tool and is heavily tested in interviews at Indian product companies.

Aggregation pipeline:

1. A pipeline is a sequence of stages; each stage transforms the documents and passes the result to the next stage
2. $match: filter documents early in the pipeline (like a WHERE clause); place $match as early as possible to reduce the number of documents processed by downstream stages
3. $group: group documents by a key and compute aggregations: { _id: '$status', count: { $sum: 1 }, total: { $sum: '$amount' } }
4. Accumulator operators in $group: $sum, $avg, $min, $max, $count, $push (collect values into an array), $addToSet (collect unique values)
5. $project: reshape documents — include or exclude fields, add computed fields: { name: 1, fullName: { $concat: ['$firstName', ' ', '$lastName'] } }
6. $sort: sort documents: { amount: -1 } (descending), { name: 1 } (ascending)
7. $limit and $skip: pagination
8. $lookup: left outer join with another collection: { from: 'users', localField: 'userId', foreignField: '_id', as: 'user' }
9. $unwind: deconstruct an array field into separate documents (one document per array element); useful before $group on array elements
10. $addFields: add new fields to documents without removing existing fields
11. $count: count the number of documents at this stage of the pipeline

Indexing strategies:

1. Single field index: db.collection.createIndex({ email: 1 }) — ascending index on email
2. Compound index: db.collection.createIndex({ status: 1, createdAt: -1 }) — important: field order matters; the index supports queries on status alone and on (status, createdAt) combined
3. The ESR rule: place Equality filters first, Sort fields second, Range filters third in compound indexes
4. Multikey index: automatically created when a field contains an array; indexes each array element
5. Text index: db.collection.createIndex({ description: 'text' }) — enables full-text search with $text operator
6. Partial index: { partialFilterExpression: { status: 'active' } } — only indexes documents matching the filter; smaller index, faster queries on the filtered subset
7. TTL (Time To Live) index: { expireAfterSeconds: 3600 } — MongoDB automatically deletes documents after the TTL expires; used for sessions, logs, cache entries
8. explain(): use db.collection.find({...}).explain('executionStats') to analyse query performance; look for COLLSCAN (collection scan — no index used) vs IXSCAN (index scan)

Replica sets and sharding are tested for senior MongoDB roles and at companies running MongoDB in production at scale.

Replica sets:

1. A replica set is a group of MongoDB nodes that maintain the same data; provides high availability and automatic failover
2. Primary: the single node that accepts all write operations; replicates writes to secondaries via the oplog (operation log)
3. Secondary: replicates from the primary; can serve reads (if configured); automatically elected as new primary if the current primary goes down
4. Arbiter: votes in elections but does not hold data; used when you want an odd number of voting members without the cost of a full data-bearing node
5. Write concern: controls acknowledgement before returning success to the client; w:1 (primary acknowledged), w:'majority' (majority of voting members acknowledged — safer, higher latency)
6. Read preference: primaryPreferred (read from primary; fall back to secondary), secondary (always read from secondary — may return stale data), nearest (lowest network latency)
7. Oplog: a capped collection that records all write operations in order; secondaries tail the oplog to replicate

Sharding:

1. Sharding is horizontal scaling — data is distributed across multiple replica sets (shards)
2. Shard key: the field(s) used to determine which shard a document belongs to; chosen at collection creation; cannot be easily changed later
3. Range-based sharding: documents are distributed based on shard key value ranges; efficient for range queries but risks hotspots for monotonically increasing keys (like ObjectId or timestamp)
4. Hashed sharding: MongoDB hashes the shard key value; distributes data evenly; poor for range queries
5. Chunk: MongoDB divides the shard key space into chunks; chunks are migrated between shards by the balancer to maintain even distribution
6. mongos: the query router that routes requests to the correct shard(s); clients connect to mongos, not directly to shards

Schema design patterns:

1. Bucket pattern: group related time-series data into documents (e.g., one document per hour with an array of measurements); reduces document count and improves range query performance
2. Computed pattern: pre-compute frequently accessed aggregations (e.g., order total) and store them in the document to avoid expensive real-time aggregation
3. Subset pattern: store a subset of related data (e.g., the last 10 reviews) in the parent document; store the full list in a separate collection