MongoDB Cheat Sheet

MongoDB vs SQL — Terminology Map

Document Structure (BSON)

BSON Data Types

ObjectId Structure

INSERT ⭐

FIND (READ) ⭐

UPDATE ⭐

DELETE ⭐

bulkWrite — Batch Operations ⭐

Comparison Operators ⭐

Logical Operators ⭐

Element & Evaluation Operators

Array Operators ⭐

Field Update Operators ⭐

Array Update Operators ⭐

Pipeline Updates (MongoDB 4.2+) ⭐

Pipeline Concept & Structure ⭐

$group Accumulators ⭐

Aggregation Expressions ⭐

$lookup — JOIN ⭐

Stage Quick Reference

$facet — Multiple Pipelines ⭐

$project Advanced

Index Types Reference

Create & Manage Indexes

explain() — Query Analysis ⭐

Index Rules & Tips ⭐

Embed vs Reference — When to Use Which ⭐

💡 Rule of thumb: "If you're always loading B with A, embed it. If you load B independently, reference it."

Embedding (Denormalization)

References (Normalization)

Bucket Pattern ⭐ (IoT, time-series)

Outlier, Subset & Computed Patterns

Schema Validation (MongoDB 3.6+)

One-to-One, One-to-Many, Many-to-Many

$lookup With Population ⭐

Multi-Document Transactions (MongoDB 4.0+) ⭐

Single Document is Always Atomic ⭐

Read/Write Concerns

Connect & Schema

Mongoose CRUD ⭐

Virtuals, Methods & Middleware ⭐

Populate (Joins) ⭐

mongosh Commands ⭐

Connection String URI

Performance Tips ⭐

Capped Collections & Change Streams

Classic MongoDB Traps

Never use $where in production. It executes JavaScript in the database — extremely slow (can't use indexes) and a security risk.

$lookup creates an array — always $unwind after. Forgetting to unwind leaves you with an array field instead of embedded object. Use preserveNullAndEmptyArrays: true to keep unmatched docs.

Unbounded arrays are dangerous. Embedding an ever-growing array (like all comments on a viral post) hits the 16MB document limit. Use a separate collection once count can grow large.

$set vs replaceOne. Forgetting $set in updateOne replaces the entire document except _id. Always use update operators ($set, $inc, etc.) unless you want a full replace.

Mongoose .lean() for read performance. Without .lean(), Mongoose wraps every doc in a full Mongoose document (with methods, virtuals). Use .lean() for read-only queries — 3-10x faster.

Transactions require Replica Set. Multi-document transactions don't work on standalone MongoDB instances. Need at least a 1-node replica set even in development.

Case-sensitive queries. MongoDB queries are case-sensitive by default. Use $regex: /pattern/i or store normalized lowercase in a separate field for case-insensitive search.

null vs missing fields. { field: null } matches documents where field is null AND where field doesn't exist. Use $exists to distinguish them.

Q1 ⭐ What is MongoDB? How is it different from relational databases like MySQL?

MongoDB = NoSQL, document-oriented database. Stores data as BSON documents (JSON-like).
MySQL = Relational, table-row model, fixed schema, SQL language.
MongoDB: flexible schema, horizontal scaling (sharding), no JOINs (embed/reference), good for unstructured/semi-structured data.
MySQL: ACID compliance, strong consistency, complex queries via SQL JOINs, better for structured relational data.

🔗 Follow-up: "When would you choose MongoDB over MySQL?"

Q2 ⭐ What is a document in MongoDB? What is BSON?

Document = basic unit of data in MongoDB. A JSON-like object with key-value pairs.
BSON = Binary JSON. MongoDB's storage format. Extends JSON with additional types: Date, ObjectId, Int32, Binary, Decimal128.
Document size limit = 16MB. _id field is required and unique.
Documents in same collection don't need same structure (flexible schema).

Q3 ⭐ What is an ObjectId? What information does it contain?

ObjectId = 12-byte BSON type used as default _id. 24 hex characters.
Structure: 4 bytes timestamp + 5 bytes random (machine+process) + 3 bytes incrementing counter.
Guaranteed unique across machines. Can extract creation time from _id.
Sorted by insertion time — ObjectId("...").getTimestamp() gives creation date.

Q4: What is the difference between find() and findOne()?

find(): returns a cursor over all matching documents. Can chain sort/limit/skip.
findOne(): returns the first matching document directly (null if not found). Stops after finding first match.
findOne() is slightly more efficient when you only need one result.
Both accept same query filter and projection syntax.

Q5: What is the difference between insertOne() and insertMany()? What is ordered: false?

insertOne(): inserts a single document. Returns insertedId.
insertMany(): inserts array of documents. Returns insertedIds array.
ordered: true (default): stops on first error. ordered: false: continues inserting remaining docs even if some fail.
Use ordered: false for bulk imports where partial failure is acceptable.

Q6: What is the difference between updateOne() with $set vs replaceOne()?

updateOne with $set: updates only specified fields. Other fields unchanged.
replaceOne: replaces the ENTIRE document except _id. All other fields gone.
updateOne without operator: treats update doc as replacement (same as replaceOne).
Always use $set, $inc, etc. in updateOne unless intentional full replacement.

Q7: What is upsert in MongoDB? Give a use case.

Upsert: update if found, insert if not. Option: { upsert: true } on updateOne/updateMany.
Use $setOnInsert for fields to set only when creating a new document.
Use case: user preferences — create if first visit, update if returning.
Use case: analytics counters — create with count:1 if new, increment if exists.

Q8: What are MongoDB indexes? Why are they important?

Index = special data structure (B-tree) that stores subset of collection in easily traversable form.
Without index: COLLSCAN — scans every document. Slow for large collections.
With index: IXSCAN — jumps directly to matching docs. Dramatically faster.
Tradeoff: Indexes speed up reads but slow down writes (index must be updated) and use disk space.

Q9 ⭐ What is the Aggregation Pipeline in MongoDB? How does it work?

Pipeline = array of stages. Documents flow through sequentially, each stage transforms the data.
Key stages: $match (filter), $group (aggregate), $project (reshape), $sort, $limit, $lookup (join), $unwind (flatten array).
More powerful than find() — can compute, join, reshape, bucket data.
$match early to filter docs before expensive stages. Index is used by $match.

🔗 Follow-up: "Write an aggregation to find total revenue per product category."

Q10 ⭐ When would you embed vs reference documents in MongoDB?

Embed: always access together, one-to-few, small/bounded data, data changes rarely.
Reference: access independently, one-to-many/many-to-many, large/unbounded data, data changes frequently.
Embedding = 1 query, fast read, potential data duplication.
Referencing = clean model, possible N+1 queries, flexible.

Q11 ⭐ What is $lookup? How does it compare to SQL JOIN?

$lookup = aggregation stage that performs a left outer join with another collection.
Adds matched documents as an array field. Use $unwind to flatten to single object.
vs SQL JOIN: $lookup only available in aggregation pipeline. SQL JOIN is native to SELECT.
Pipeline $lookup (v3.6+): allows filtering, sorting, limiting the joined data inline.

Q12: What is a compound index? What is the ESR rule?

Compound index: index on multiple fields — { city: 1, age: -1, name: 1 }
Leftmost prefix rule: compound on (a,b,c) supports queries on a; a+b; a+b+c. NOT b alone or c alone.
ESR rule: Equality fields first, Sort fields second, Range fields last. Optimal compound index order.
Example: { status: 1, createdAt: -1, price: 1 } for query filtering by status, sorting by date, filtering price range.

Q13: What is a TTL index? What is it used for?

TTL (Time-To-Live) index: special single-field index on a Date field. Automatically deletes documents after specified seconds.
MongoDB background thread checks every 60 seconds — not exact to the second.
Use cases: session tokens, OTP codes, cache collections, log data, notifications.
<code>createIndex({ createdAt: 1 }, { expireAfterSeconds: 3600 })</code>

Q14: Does MongoDB support ACID transactions? When were they introduced?

Single-document: ALWAYS atomic. All field updates in one document are atomic.
Multi-document transactions: Added in MongoDB 4.0 (replica sets), 4.2 (sharded clusters).
Supports full ACID: Atomicity, Consistency, Isolation, Durability across multiple documents.
Best practice: design schema to avoid transactions when possible (embed related data). Use transactions for true financial operations.

Q15: What is a Replica Set in MongoDB? What problem does it solve?

Replica Set = group of MongoDB nodes (typically 3) that maintain same dataset.
One primary (accepts writes), multiple secondaries (replicate from primary).
Solves: high availability (auto failover if primary dies), read scaling (read from secondaries).
Elections: if primary fails, secondaries elect a new primary automatically.

Q16: What is sharding in MongoDB? When would you use it?

Sharding = horizontal scaling. Distributes data across multiple machines (shards).
Each shard holds a subset of data, determined by the shard key.
Use when: single server can't hold all data OR write throughput exceeds single node capacity.
Shard key choice is critical — avoid hotspots. Good: sequential + high cardinality. Bad: boolean, low-cardinality fields.

Q17 ⭐ How does MongoDB handle concurrency? What is MVCC?

MongoDB uses MVCC (Multi-Version Concurrency Control) via the WiredTiger storage engine.
Readers don't block writers and writers don't block readers — snapshot isolation.
Document-level locking: different documents can be written concurrently.
Collection and database level locks exist for DDL operations (creating indexes, dropping collections).

Q18 ⭐ What is a covered query? How does it improve performance?

Covered query: ALL fields in the query (filter + projection) are in the index. No document fetch needed.
MongoDB can satisfy the query entirely from the index — no reading from disk for documents.
Create: <code>createIndex({ email: 1, name: 1 })</code> then query: <code>find({ email: "..." }, { name: 1, _id: 0 })</code>
_id must be excluded in projection for covered query (unless _id is in index).

Q19: Explain the WiredTiger storage engine. What are its advantages?

WiredTiger: default storage engine since MongoDB 3.2. Replaced MMAPv1.
Features: document-level locking, compression (Snappy/zlib — 80% space savings), MVCC, journaling.
Compression: reduces disk usage and IO. Snappy (default) = fast. zlib = smaller.
Cache: uses a portion of RAM as cache. Configurable via wiredTigerCacheSizeGB.

Q20: What are Change Streams? What is their use case?

Change Streams: real-time notification of data changes (insert/update/delete/replace).
Built on MongoDB's oplog (operation log). Requires replica set or sharded cluster.
Use cases: real-time dashboards, event-driven architecture, cache invalidation, audit logging.
Can filter events with aggregation pipeline. Resumable (resume tokens for reconnect).

Q21: What is the difference between $group with _id: null vs $count?

$group with _id: null: groups ALL documents into one group. Can apply multiple accumulators (sum, avg, max, etc.).
$count: shorthand stage that counts documents and outputs { fieldName: count }. Only counts.
$group { _id: null, total: { $sum: 1 } } = equivalent to $count but can compute more things at once.
For just counting: use $count. For count + aggregates: use $group with _id: null.

Q22: How would you design a schema for a social media app with users, posts, likes, and comments at scale?

Users: separate collection. Posts: separate collection with userId reference.
Comments: separate collection (not embedded — can grow unbounded).
Likes: counters in post document + separate likes collection for "did I like this?" queries.
Use computed pattern: store likeCount in post, increment/decrement atomically. Faster than counting likes collection.
Subset pattern: embed top N comments in post, rest in comments collection. Use flag hasMoreComments.
Indexes: posts on { userId, createdAt }, comments on { postId, createdAt }, likes on { postId, userId } unique.