MongoDB:
Beginner to Advanced

MongoDB supports distributed ACID transactions across multiple documents, collections, databases, and shards (4.0+ replica sets, 4.2+ sharded clusters). Transactions commit all changes or roll back entirely. Uncommitted changes are never visible outside the transaction. Default runtime limit is 1 minute via transactionLifetimeLimitSeconds.

// Atomic bank transfer — debit + credit + ledger
const session = client.startSession()

try {
  session.startTransaction({
    readConcern:  { level: "snapshot" },
    writeConcern: { w: "majority" }
  })

  // Debit sender
  await db.accounts.updateOne(
    { _id: senderId, balance: { $gte: amount } },
    { $inc: { balance: -amount } },
    { session }
  )

  // Credit receiver
  await db.accounts.updateOne(
    { _id: receiverId },
    { $inc: { balance: +amount } },
    { session }
  )

  // Append to ledger
  await db.ledger.insertOne(
    { from: senderId, to: receiverId, amount, ts: new Date() },
    { session }
  )

  await session.commitTransaction()

} catch (err) {
  await session.abortTransaction()
} finally {
  await session.endSession()
}

Enforce document structure at the database level. validationAction: 'error' rejects invalid writes. 'warn' logs without rejecting. validationLevel: 'strict' applies to all inserts and updates. 'moderate' applies only to inserts and updates of currently valid documents.

db.createCollection("orders", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["customerId", "items", "total", "status"],
      properties: {
        customerId: { bsonType: "objectId" },
        items: {
          bsonType: "array", minItems: 1,
          items: {
            required: ["sku", "qty", "price"],
            properties: {
              sku:   { bsonType: "string" },
              qty:   { bsonType: "int", minimum: 1 },
              price: { bsonType: "double", minimum: 0 }
            }
          }
        },
        status: {
          bsonType: "string",
          enum: ["pending", "processing", "shipped", "completed", "cancelled"]
        }
      }
    }
  },
  validationAction: "error",
  validationLevel:  "strict"
})

A replica set is a group of mongod processes maintaining the same dataset. One primary accepts all writes; secondaries replicate the primary's oplog asynchronously. On primary failure, an eligible secondary holds an election automatically. All production deployments must use replica sets. Reads can be distributed to secondaries with read preferences.

// Initiate a 3-member replica set
rs.initiate({
  _id: "rs0",
  members: [
    { _id: 0, host: "mongo1:27017", priority: 2 },
    { _id: 1, host: "mongo2:27017", priority: 1 },
    { _id: 2, host: "mongo3:27017", priority: 1 }
  ]
})

// Check status
rs.status()

// Read from nearest secondary (Node.js driver)
const client = new MongoClient(uri, {
  readPreference: "secondaryPreferred"
})

// Write concern — majority acknowledgement + journal
db.orders.insertOne(doc, {
  writeConcern: { w: "majority", j: true }
})

Sharding distributes data across multiple shards (each a replica set) using a shard key. The mongos router directs queries to the appropriate shards. Config servers store cluster metadata. Choose a shard key with high cardinality and even distribution to avoid hotspots. Once sharded, a collection cannot be unsharded.

// Enable sharding on a database
sh.enableSharding("ecommerce")

// Hashed shard key — even distribution
sh.shardCollection(
  "ecommerce.orders",
  { customerId: "hashed" }
)

// Range shard key — good for time-series range queries
sh.shardCollection(
  "ecommerce.events",
  { createdAt: 1 }
)

// Check sharding status
sh.status()
sh.getBalancerState()

Change streams (MongoDB 3.6+) let applications subscribe to real-time data changes on a collection, database, or deployment — without tailing the oplog. Available on WiredTiger replica sets and sharded clusters. Each event includes operationType, documentKey, and optional pre/post images (MongoDB 6.0+). Streams are resumable via a resumeToken.

// Watch only inserts and updates for pending orders
const pipeline = [
  { $match: {
    operationType: { $in: ["insert", "update"] },
    "fullDocument.status": "pending"
  }}
]

const changeStream = db.collection("orders").watch(pipeline, {
  fullDocument: "updateLookup"
})

for await (const change of changeStream) {
  const { operationType, fullDocument } = change

  if (operationType === "insert")
    await notifyWarehouse(fullDocument)
  if (operationType === "update")
    await sendStatusEmail(fullDocument)

  // Save token to resume after restart
  saveResumeToken(change._id)
}

// Resume from last known position
const stream = db.collection("orders").watch([], {
  resumeAfter: savedResumeToken
})

Write concern controls how many replica set members must acknowledge a write. w: 'majority' ensures durability. Read concern controls consistency — 'local' (default, fastest), 'majority' (committed to majority), 'snapshot' (point-in-time, required for multi-shard transactions).

// Strong write — majority + journal flush
db.payments.insertOne(doc, {
  writeConcern: { w: "majority", j: true, wtimeout: 5000 }
})

// Snapshot read concern — used in transactions
const session = client.startSession()
session.startTransaction({
  readConcern:  { level: "snapshot" },
  writeConcern: { w: "majority" }
})

// Route reads to nearest replica
db.collection("analytics").find(
  { date: today },
  { readPreference: "nearest" }
)

Key practices from the official MongoDB performance documentation.

• Follow the ESR guideline for compound indexes: Equality → Sort → Range fields
• Use covered queries — all queried and projected fields must be in the index so MongoDB never reads documents
• Place $match (with indexed fields) as the very first aggregation stage to leverage indexes
• Use projection to return only needed fields — reduces document size in transit
• Prefer embedding over referencing for data always read together — avoids $lookup overhead
• Keep working set (indexes + hot data) in RAM — monitor with db.stats() and db.serverStatus()
• Use connection pooling in all drivers — never create a new MongoClient per request
• Monitor slow queries with db.setProfilingLevel(1, { slowms: 100 }) and inspect system.profile
• Avoid unbounded array growth — use separate collections or $slice projections
• Avoid $where and JavaScript queries — they cannot use indexes and run in a JS interpreter
• Minimise index count on write-heavy collections — each write must update all indexes
• Use bulkWrite() to batch inserts/updates and reduce network round trips