Chapter 11: MongoDB & Mongoose Deep Dive: Schemas, Indexes, Aggregation, and Performance

JSON (Text Format):
{"name": "Alice", "age": 28, "created": "2026-03-24T10:00:00Z"}
• Human-readable text
• Supports only 6 data types: string, number, boolean, null, array, object
• Slow to parse (requires scanning characters)

BSON (Binary Representation on Disk):
\x16\x00\x00\x00\x02name\x00\x06\x00\x00\x00Alice\x00\x10age\x00\x1c\x00\x00\x00...
• Fast binary parsing with prefixed byte-lengths
• Rich data types: ObjectId, Date, 64-bit Int, Decimal128, Binary/Buffer, RegEx
• Enables fast skipping of fields without deserializing the entire document

EMBEDDING (Data inside the same document):
{
  "_id": ObjectId("65b..."),
  "name": "Sarah Connor",
  "shippingAddress": {
    "street": "123 Cyber Way",
    "city": "Los Angeles",
    "zip": "90210"
  }
}
• 1 disk read fetches everything
• Atomic updates guaranteed
• Ideal for 1-to-1 or 1-to-Few relationships

REFERENCING (Linked by ID across collections):
Users Collection:
{ "_id": ObjectId("user_1"), "name": "Sarah" }

Orders Collection:
{ "_id": ObjectId("order_101"), "userId": ObjectId("user_1"), "total": 85.50 }
{ "_id": ObjectId("order_102"), "userId": ObjectId("user_1"), "total": 120.00 }
• Documents stay small and independent
• Prevents hitting the 16MB limit
• Ideal for 1-to-Many or 1-to-Squillions

// features/products/product.model.js
import mongoose from 'mongoose';

const productSchema = new mongoose.Schema(
  {
    name: {
      type: String,
      required: [true, 'Product name is required'],
      trim: true,
      minlength: [3, 'Name must be at least 3 characters'],
      maxlength: [120, 'Name cannot exceed 120 characters'],
    },
    slug: {
      type: String,
      unique: true,
      lowercase: true,
      index: true,
    },
    price: {
      type: Number,
      required: [true, 'Price is required'],
      min: [0, 'Price cannot be negative'],
    },
    category: {
      type: String,
      required: true,
      enum: ['electronics', 'apparel', 'books', 'home'],
      index: true,
    },
    stock: {
      type: Number,
      required: true,
      default: 0,
      min: 0,
    },
    ratingsAverage: {
      type: Number,
      default: 4.5,
      min: [1, 'Rating must be above 1.0'],
      max: [5, 'Rating must be below 5.0'],
      set: (val) => Math.round(val * 10) / 10, // Rounds 4.6666 to 4.7
    },
    ratingsQuantity: {
      type: Number,
      default: 0,
    },
    isDeleted: {
      type: Boolean,
      default: false,
      select: false, // Soft-delete flag hidden by default
    },
  },
  {
    timestamps: true,
    toJSON: { virtuals: true },
    toObject: { virtuals: true },
  }
);

// Virtual: Calculate discount price dynamically
productSchema.virtual('discountedPrice').get(function () {
  const DISCOUNT_RATE = 0.1; // 10% discount
  return this.price * (1 - DISCOUNT_RATE);
});

// Virtual Populate: Connect reviews without storing an unbounded array in Product!
productSchema.virtual('reviews', {
  ref: 'Review',
  foreignField: 'productId',
  localField: '_id',
});

// A. INSTANCE METHOD: Operates on a single document instance (uses `this` as doc)
productSchema.methods.isInStock = function (requestedQuantity = 1) {
  return this.stock >= requestedQuantity;
};

// B. STATIC METHOD: Operates on the entire Model collection (uses `this` as Model)
productSchema.statics.findByCategory = function (category) {
  return this.find({ category, isDeleted: false });
};

// C. QUERY HELPER: Extends Mongoose's chainable query builder (.find().byCategory('books'))
productSchema.query.active = function () {
  return this.where({ isDeleted: false });
};

// Usage:
// const inStock = product.isInStock(2);                       // Instance method
// const products = await Product.findByCategory('electronics'); // Static method
// const active = await Product.find().active();                // Query helper

// Document Hook: Auto-generate URL slug from product name before saving
productSchema.pre('save', function (next) {
  if (this.isModified('name')) {
    this.slug = this.name
      .toLowerCase()
      .replace(/[^a-z0-9]+/g, '-')
      .replace(/(^-|-$)+/g, '');
  }
  next();
});

// Query Hook: Automatically filter out soft-deleted products on every find query
productSchema.pre(/^find/, function (next) {
  // Regex /^find/ matches find, findOne, findById, findOneAndUpdate, etc.
  this.find({ isDeleted: { $ne: true } });
  next();
});

QUERY: db.users.find({ email: "alex@example.com" }) in a 1,000,000-document collection

WITHOUT INDEX (COLLSCAN):
Algorithm: Linear Scan O(N)
Documents Examined: 1,000,000 documents
Data Read: If 1 document = 1 KB, MongoDB reads ~1,000,000 KB (1 GIGABYTE) from disk/RAM!
Comparisons: 1,000,000 string comparisons
Execution Time: ~650 ms to 1,200 ms
CPU Utilization: 100% of a CPU core pinned during the scan

WITH B+ TREE INDEX (IXSCAN):
Algorithm: Tree Traversal O(log N) with Branching Factor B ≈ 200
Tree Depth for 1,000,000 entries:
  • Level 1 (Root Node): 1 page read (covers ~200 ranges)
  • Level 2 (Internal Node): 1 page read (covers ~40,000 ranges)
  • Level 3 (Leaf Node): 1 page read (contains the exact pointer to the document!)
Total Pages Read: Only 3 to 4 index pages (approx. 16 KB of data!)
Execution Time: ~0.8 ms to 1.5 ms
Speedup Factor: OVER 600x FASTER!

┌────────────────────────────────────────────────────────────────────────────────────────┐
│                   BENCHMARK: 100 CONCURRENT USERS (1M DOCUMENT COLLECTION)             │
├──────────────────────────┬─────────────────────────────┬───────────────────────────────┤
│ Metric                   │ WITHOUT INDEX (COLLSCAN)    │ WITH INDEX (IXSCAN)           │
├──────────────────────────┼─────────────────────────────┼───────────────────────────────┤
│ Average Response Time    │ 32,400 ms (32.4 SECONDS!)   │ 4.2 ms                        │
│ 99th Percentile (p99)    │ TIMED OUT (504 Gateway)     │ 8.6 ms                        │
│ Throughput (RPS)         │ 14 requests/sec (Clogged)   │ 4,150 requests/sec            │
│ Database CPU Usage       │ 100% (All cores pinned)     │ 7%                            │
│ Memory I/O Pressure      │ Thrashing disk cache        │ Minimal (fits in RAM cache)   │
└──────────────────────────┴─────────────────────────────┴───────────────────────────────┘

// Index on email in ascending order (1)
userSchema.index({ email: 1 }, { unique: true });

// Compound index on category (ascending) and price (descending)
productSchema.index({ category: 1, price: -1 });

const otpSchema = new Schema({
  email: String,
  code: String,
  createdAt: { type: Date, default: Date.now, expires: 300 }, // Auto-deleted after 5 minutes (300s)!
});

// Only index active users
userSchema.index(
  { email: 1 },
  { partialFilterExpression: { isActive: true } }
);

// Indexing category, then createdAt, then price
productSchema.index({ category: 1, createdAt: -1, price: 1 });

┌─────────────────┬──────────────────┬──────────────┐
│ LAST NAME (ASC) │ FIRST NAME (ASC) │ PHONE NUMBER │
├─────────────────┼──────────────────┼──────────────┤
│ "Adams"         │ "Abigail"        │ 555-0101     │
│ "Adams"         │ "Benjamin"       │ 555-0102     │
│ "Smith"         │ "Alice"          │ 555-0201     │
│ "Smith"         │ "Bob"            │ 555-0202     │
│ "Smith"         │ "Charlie"        │ 555-0203     │
│ "Taylor"        │ "David"          │ 555-0301     │
└─────────────────┴──────────────────┴──────────────┘

Compound Index: { category: 1, createdAt: -1, price: 1 }

Sorted Index Entries on Disk:
┌────────────────┬──────────────────────┬─────────┬──────────────┐
│ category (ASC) │ createdAt (DESC)     │ price   │ Document ID  │
├────────────────┼──────────────────────┼─────────┼──────────────┤
│ "electronics"  │ 2026-03-20T12:00:00Z │ $150    │ ──► Doc #101 │
│ "electronics"  │ 2026-03-20T08:00:00Z │ $400    │ ──► Doc #102 │
│ "electronics"  │ 2026-03-19T14:00:00Z │ $250    │ ──► Doc #103 │
│ "footwear"     │ 2026-03-22T10:00:00Z │ $80     │ ──► Doc #104 │
│ "footwear"     │ 2026-03-18T16:00:00Z │ $120    │ ──► Doc #105 │
└────────────────┴──────────────────────┴─────────┴──────────────┘

┌───────────────────────┐       ┌───────────────────────┐       ┌───────────────────────┐
│    1. EQUALITY (E)    │       │      2. SORT (S)      │       │     3. RANGE (R)      │
│  Exact match fields   │ ────► │  Sort order fields    │ ────► │  Range filter fields  │
│  { category: "tech" } │       │  { createdAt: -1 }    │       │  { price: { $gte } }  │
└───────────────────────┘       └───────────────────────┘       └───────────────────────┘

// Query: Find active electronics between $100 and $500, newest first
db.products.find({
  category: 'electronics',        // Equality (E)
  price: { $gte: 100, $lte: 500 } // Range (R)
}).sort({ createdAt: -1 });       // Sort (S)

const stats = await Product.find({ category: 'electronics' })
  .sort({ price: -1 })
  .explain('executionStats');

console.log(JSON.stringify(stats.executionStats, null, 2));

{
  "executionSuccess": true,
  "nReturned": 25,
  "executionTimeMillis": 2,
  "totalKeysExamined": 25,
  "totalDocsExamined": 25,
  "executionStages": {
    "stage": "FETCH",
    "inputStage": {
      "stage": "IXSCAN",
      "indexName": "category_1_price_-1"
    }
  }
}

// Covered Query Example:
// Index exists on: { category: 1, slug: 1 }
const result = await Product.find(
  { category: 'electronics' },
  { slug: 1, _id: 0 } // Only requesting indexed fields!
);
// totalDocsExamined will be 0! Blazing fast!

Raw Documents (10,000)
       │
       ▼
 1. $match     ──► Filters documents (narrows 10,000 down to 800)
       │
       ▼
 2. $lookup    ──► Performs Left Outer Join with another collection
       │
       ▼
 3. $unwind    ──► Flattens joined array elements
       │
       ▼
 4. $group     ──► Groups by field & calculates totals, averages ($sum, $avg)
       │
       ▼
 5. $sort      ──► Orders the aggregated output
       │
       ▼
 6. $project   ──► Reshapes the final response shape
       │
       ▼
Final Aggregated Report (5 summary rows)

// features/orders/order.service.js
import { OrderModel } from './order.model.js';

export class OrderService {
  async getMonthlyRevenueStats(year) {
    const stats = await OrderModel.aggregate([
      // Stage 1: Filter to completed orders in the given year
      {
        $match: {
          status: 'completed',
          createdAt: {
            $gte: new Date(`${year}-01-01`),
            $lte: new Date(`${year}-12-31`),
          },
        },
      },

      // Stage 2: Group by month number
      {
        $group: {
          _id: { $month: '$createdAt' }, // Groups by month (1 to 12)
          totalOrders: { $sum: 1 },
          totalRevenue: { $sum: '$totalAmount' },
          avgOrderValue: { $avg: '$totalAmount' },
          minOrderValue: { $min: '$totalAmount' },
          maxOrderValue: { $max: '$totalAmount' },
        },
      },

      // Stage 3: Project and reshape the output fields
      {
        $project: {
          _id: 0,
          month: '$_id',
          totalOrders: 1,
          totalRevenue: { $round: ['$totalRevenue', 2] },
          avgOrderValue: { $round: ['$avgOrderValue', 2] },
        },
      },

      // Stage 4: Sort chronologically by month
      {
        $sort: { month: 1 },
      },
    ]);

    return stats;
  }
}

// features/products/product.service.js
export class ProductService {
  async searchProducts({ category, minPrice, maxPrice, page = 1, limit = 20 }) {
    const skip = (page - 1) * limit;

    const [result] = await ProductModel.aggregate([
      // Match Stage
      {
        $match: {
          ...(category && { category }),
          price: {
            $gte: minPrice || 0,
            $lte: maxPrice || 100000,
          },
          isDeleted: false,
        },
      },

      // Facet Stage: Runs two independent sub-pipelines simultaneously!
      {
        $facet: {
          // Sub-pipeline 1: Paginated Data
          items: [
            { $sort: { createdAt: -1 } },
            { $skip: skip },
            { $limit: limit },
            { $project: { name: 1, price: 1, category: 1, ratingsAverage: 1 } },
          ],

          // Sub-pipeline 2: Metadata & Analytics
          metadata: [
            {
              $group: {
                _id: null,
                totalItems: { $sum: 1 },
                avgPrice: { $avg: '$price' },
                minPrice: { $min: '$price' },
                maxPrice: { $max: '$price' },
              },
            },
          ],
        },
      },

      // Reshape the output
      {
        $project: {
          items: 1,
          total: { $ifNull: [{ $arrayElemAt: ['$metadata.totalItems', 0] }, 0] },
          stats: { $arrayElemAt: ['$metadata', 0] },
        },
      },
    ]);

    return {
      items: result.items,
      total: result.total,
      stats: result.stats,
      page,
      limit,
    };
  }
}

// ❌ SLOW: Hydrates 500 heavy Mongoose Document objects
const products = await Product.find({ category: 'electronics' });

// ✅ SIGNIFICANTLY FASTER: Returns plain, raw JavaScript objects directly from BSON
const products = await Product.find({ category: 'electronics' }).lean();

// What you write:
const orders = await Order.find().populate('userId');

// What Mongoose actually runs behind the scenes:
// Query 1: db.orders.find()  ──► returns 100 orders with 100 userIds
// Query 2: db.users.find({ _id: { $in: [id1, id2, ... id100] } })

import mongoose from 'mongoose';
import { ProductModel } from '../products/product.model.js';
import { OrderModel } from './order.model.js';
import { ApiError } from '../../shared/errors/api-error.js';

export async function createOrderWithInventoryCheck({ userId, productId, quantity }) {
  // 1. Start a client session
  const session = await mongoose.startSession();

  try {
    let createdOrder;

    // 2. Execute operations inside withTransaction
    await session.withTransaction(async () => {
      // Step A: Decrement stock atomically (must pass { session })
      const product = await ProductModel.findOneAndUpdate(
        { _id: productId, stock: { $gte: quantity } }, // Condition ensures stock >= requested
        { $inc: { stock: -quantity } },
        { new: true, session }
      );

      if (!product) {
        throw ApiError.badRequest('Insufficient product stock or product not found');
      }

      // Step B: Create order (must pass [doc], { session })
      const [order] = await OrderModel.create(
        [
          {
            userId,
            productId,
            quantity,
            totalAmount: product.price * quantity,
            status: 'completed',
          },
        ],
        { session }
      );

      createdOrder = order;
    });

    // If transaction finishes without error, changes are committed!
    return createdOrder;
  } catch (error) {
    // If any error was thrown, the transaction automatically rolled back!
    // The product stock is completely restored to its original value.
    throw error;
  } finally {
    // 3. Always end the session to return connection to the pool
    await session.endSession();
  }
}

// db.js
import mongoose from 'mongoose';

export async function connectDB() {
  const MONGO_URI = process.env.MONGO_URI;

  const options = {
    maxPoolSize: 50,          // Maximum number of concurrent socket connections
    minPoolSize: 10,          // Keep 10 idle connections warm and ready
    serverSelectionTimeoutMS: 5000, // Fail fast after 5s if cluster is unreachable
    socketTimeoutMS: 45000,   // Close sockets inactive for 45s
  };

  try {
    await mongoose.connect(MONGO_URI, options);
    console.log('✅ Connected to MongoDB Replica Set');
  } catch (err) {
    console.error('❌ Failed to connect to MongoDB:', err.message);
    process.exit(1);
  }

  // Monitor connection events
  mongoose.connection.on('disconnected', () => {
    console.warn('⚠️ MongoDB connection lost. Mongoose will attempt reconnect...');
  });

  mongoose.connection.on('reconnected', () => {
    console.log('🔄 MongoDB reconnected successfully');
  });
}

// Write Concern Options:
// w: 1         — Acknowledged by the primary only (default). Fast, but if the primary
//                 crashes before replication, the write is LOST.
// w: "majority" — Acknowledged only after a majority of voting members have written
//                 the data to their on-disk journal. Durable against failovers.
// w: 0         — Fire-and-forget. No acknowledgment at all. Maximum throughput,
//                 zero durability guarantee.

// Setting write concern at the connection level:
await mongoose.connect(MONGO_URI, {
  w: 'majority',        // All writes require majority acknowledgment
  journal: true,        // Wait for journal commit (on-disk durability)
  wtimeoutMS: 5000,     // Fail if majority ack takes longer than 5 seconds
});

// Setting write concern per-operation:
await OrderModel.create([orderDoc], {
  writeConcern: { w: 'majority', j: true },
});

Read Concern Levels:
┌────────────────────┬───────────────────────────────────────────────────────────────┐
│ Level              │ Guarantee                                                     │
├────────────────────┼───────────────────────────────────────────────────────────────┤
│ "local" (default)  │ Returns the most recent data on this node.                    │
│                    │ ⚠ Data may be rolled back if the node was not in majority!    │
├────────────────────┼───────────────────────────────────────────────────────────────┤
│ "majority"         │ Returns only data that has been acknowledged by a majority    │
│                    │ of replica set members. Guaranteed NOT to be rolled back.      │
├────────────────────┼───────────────────────────────────────────────────────────────┤
│ "linearizable"     │ Strongest guarantee. Returns data that reflects ALL           │
│                    │ successful majority-acknowledged writes completed before the  │
│                    │ read began. Single-document reads only. Highest latency.      │
└────────────────────┴───────────────────────────────────────────────────────────────┘

// Read Preference Options:
// "primary"            — All reads go to primary (default). Strongest consistency.
// "primaryPreferred"   — Read from primary; if unavailable, read from secondary.
// "secondary"          — Read from secondary nodes only. Offloads primary.
//                        ⚠ Data may be slightly stale due to replication lag.
// "secondaryPreferred" — Read from secondary; if unavailable, read from primary.
// "nearest"            — Read from the node with the lowest network latency.

await mongoose.connect(MONGO_URI, {
  readPreference: 'secondaryPreferred', // Offload reads to secondaries
});

import mongoose from 'mongoose';
import { OrderModel } from './order.model.js';

// Open a change stream on the Orders collection
const changeStream = OrderModel.watch(
  // Optional: Filter pipeline — only listen for specific changes
  [
    {
      $match: {
        'operationType': { $in: ['insert', 'update'] },
        'fullDocument.status': 'shipped',
      },
    },
  ],
  {
    fullDocument: 'updateLookup', // Include the full document on update events
  }
);

// Listen for changes
changeStream.on('change', (event) => {
  console.log('Change detected:', event.operationType);
  console.log('Document:', event.fullDocument);
  console.log('Resume Token:', event._id); // Save this to resume after a crash!

  if (event.operationType === 'update') {
    // Trigger a notification, cache invalidation, etc.
    notifyUser(event.fullDocument.userId, 'Your order has been shipped!');
  }
});

// Handle errors and reconnection
changeStream.on('error', (error) => {
  console.error('Change stream error:', error);
  // In production, use the saved resume token to restart the stream
  // from where you left off, ensuring no events are missed.
});

// Resume from a saved token after restart
const savedToken = await getPersistedResumeToken(); // Load from DB or file

const changeStream = OrderModel.watch([], {
  resumeAfter: savedToken, // Resume from the last processed event
  fullDocument: 'updateLookup',
});

// ❌ SLOW: 1,000 individual network round-trips
for (const item of items) {
  await ProductModel.updateOne({ _id: item.id }, { $set: { price: item.newPrice } });
}

// ✅ FAST: 1 network request containing all 1,000 operations
const bulkOps = items.map((item) => ({
  updateOne: {
    filter: { _id: item.id },
    update: { $set: { price: item.newPrice } },
  },
}));

const result = await ProductModel.bulkWrite(bulkOps, {
  ordered: false, // Execute operations in parallel (faster, but order is not guaranteed)
});

console.log(result.modifiedCount); // Number of documents actually modified

// Create a capped collection for application logs
await mongoose.connection.db.createCollection('app_logs', {
  capped: true,
  size: 1048576,     // Maximum size: 1 MB
  max: 5000,         // Maximum number of documents: 5,000
});

// Define a Mongoose schema for the capped collection
const appLogSchema = new mongoose.Schema(
  {
    level: { type: String, enum: ['info', 'warn', 'error'], required: true },
    message: { type: String, required: true },
    metadata: mongoose.Schema.Types.Mixed,
  },
  {
    timestamps: true,
    capped: { size: 1048576, max: 5000 }, // Also declarable via Mongoose
  }
);

const userSchema = new mongoose.Schema({
  schemaVersion: { type: Number, default: 2, required: true },
  email: { type: String, required: true },
  // Version 1: had `name` as a single string
  // Version 2: split into `firstName` and `lastName`
  firstName: String,
  lastName: String,
});

// Pre-find hook: Automatically migrate old documents on read
userSchema.pre(/^find/, function (next) {
  // This is a query hook — `this` refers to the query, not a document
  next();
});

// Post-find hook: Transform documents after they're retrieved
userSchema.post(/^find/, function (docs) {
  if (!Array.isArray(docs)) docs = [docs];

  for (const doc of docs) {
    if (doc && doc.schemaVersion === 1 && doc.name) {
      // Lazy migration: Split the old `name` field into first/last
      const [first, ...rest] = doc.name.split(' ');
      doc.firstName = first;
      doc.lastName = rest.join(' ');
      doc.schemaVersion = 2;
      // Optionally persist the migration: doc.save();
    }
  }
});

┌────────────────────────────┬─────────────────────────────────────────────────────────────┐
│ Strategy                   │ When to Use                                                 │
├────────────────────────────┼─────────────────────────────────────────────────────────────┤
│ Lazy Migration (on read)   │ Documents are migrated when accessed. Zero downtime.        │
│                            │ Best when old documents are accessed infrequently.          │
├────────────────────────────┼─────────────────────────────────────────────────────────────┤
│ Eager Migration (batch)    │ Run a script to update all documents at once.               │
│                            │ Best for small collections or when all docs must conform.   │
├────────────────────────────┼─────────────────────────────────────────────────────────────┤
│ Dual-Write Pattern         │ Write to both old and new schema formats during transition. │
│                            │ Best for zero-downtime deployments with rolling updates.    │
└────────────────────────────┴─────────────────────────────────────────────────────────────┘

// Batch migration script: Convert all v1 users to v2
const result = await UserModel.updateMany(
  { schemaVersion: 1, name: { $exists: true } },
  [
    {
      $set: {
        firstName: { $arrayElemAt: [{ $split: ['$name', ' '] }, 0] },
        lastName: {
          $reduce: {
            input: { $slice: [{ $split: ['$name', ' '] }, 1, 100] },
            initialValue: '',
            in: { $concat: ['$$value', { $cond: [{ $eq: ['$$value', ''] }, '', ' '] }, '$$this'] },
          },
        },
        schemaVersion: 2,
      },
    },
    { $unset: 'name' },
  ]
);

console.log(`Migrated ${result.modifiedCount} documents from v1 to v2`);

// Create a text index on product name and description
productSchema.index(
  { name: 'text', description: 'text' },
  {
    weights: { name: 10, description: 5 }, // Name matches are weighted 2x higher
    default_language: 'english',
  }
);

// Query using $text and $search
const results = await ProductModel.find(
  { $text: { $search: 'wireless bluetooth headphones' } },
  { score: { $meta: 'textScore' } } // Include relevance score
).sort({ score: { $meta: 'textScore' } }); // Sort by relevance

// Index ALL fields in the entire document (including nested paths)
productSchema.index({ '$**': 1 });

// Index only fields under a specific path
productSchema.index({ 'metadata.$**': 1 });

Production MongoDB & Mongoose Checklist:
□ Avoid unbounded arrays in documents (prevent 16MB document cap)
□ Single-read data is embedded; independently updated data is referenced
□ Compound indexes follow the ESR rule: Equality ──► Sort ──► Range
□ All queries checked with .explain('executionStats') (ensure totalDocsExamined ≈ nReturned)
□ Read-only queries use .lean() for significant throughput boost
□ Sensitive fields marked with select: false in schema
□ Queries with populate() explicitly select only required fields
□ Multi-document critical mutations (inventory, balances) wrapped in session.withTransaction()
□ Soft-deleted documents filtered via pre(/^find/) query hooks
□ maxPoolSize configured to match application concurrency
□ Write Concern set to "majority" for critical data (payments, credentials)
□ Read Concern set to "majority" for consistency-sensitive reads
□ Change stream resume tokens persisted for crash recovery
□ Batch operations use bulkWrite() instead of individual update loops
□ Schema versioning strategy in place for document evolution