🔒 MongoDB Transactions

"All or Nothing" - Either ALL operations succeed, or NONE do

// Transaction guarantees atomicity
session.startTransaction();
try {
  // All operations as a unit
  await accounts.updateOne(
    { _id: "A" }, 
    { $inc: { balance: -100 } }
  );
  await accounts.updateOne(
    { _id: "B" }, 
    { $inc: { balance: 100 } }
  );
  await session.commitTransaction();
} catch (error) {
  // Automatically rolls back both!
  await session.abortTransaction();
}

"Rules Are Maintained" - Database goes from one valid state to another

// Consistency checks
const total = await accounts.aggregate([
  { $group: { 
    _id: null, 
    total: { $sum: "$balance" } 
  }}
]);
// total[0].total === 1000 always!

"No Interference" - Concurrent transactions don't see each other's partial changes

// Isolation levels ensure this
// snapshot isolation (default)
session.startTransaction({
  readConcern: { level: 'snapshot' },
  writeConcern: { w: 'majority' }
});

"Permanent Once Committed" - Completed transactions survive crashes/restarts

// Durability with write concern
await session.commitTransaction();
// Once this returns, data is 
// permanently stored (even if
// server crashes immediately after)

Transfer funds between accounts with guaranteed consistency

const session = client.startSession();
try {
  await session.withTransaction(async () => {
    // Debit source
    await accounts.updateOne(
      { _id: sourceId },
      { $inc: { balance: -amount } },
      { session }
    );
    
    // Credit destination
    await accounts.updateOne(
      { _id: destId },
      { $inc: { balance: amount } },
      { session }
    );
    
    // Log transaction
    await logs.insertOne({
      from: sourceId,
      to: destId,
      amount,
      timestamp: new Date()
    }, { session });
  });
} finally {
  await session.endSession();
}

Reserve inventory and create order atomically

await session.withTransaction(async () => {
  // Check stock
  const product = await products.findOne(
    { _id: productId },
    { session }
  );
  
  if (product.stock < quantity) {
    throw new Error('Out of stock!');
  }
  
  // Reduce inventory
  await products.updateOne(
    { _id: productId },
    { $inc: { stock: -quantity } },
    { session }
  );
  
  // Create order
  await orders.insertOne({
    productId,
    quantity,
    status: 'pending',
    createdAt: new Date()
  }, { session });
});

Create user, profile, and initial settings together

await session.withTransaction(async () => {
  // Create user
  const result = await users.insertOne({
    email,
    password: hashedPassword,
    createdAt: new Date()
  }, { session });
  
  const userId = result.insertedId;
  
  // Create profile
  await profiles.insertOne({
    userId,
    firstName,
    lastName,
    avatar: 'default.png'
  }, { session });
  
  // Create settings
  await settings.insertOne({
    userId,
    theme: 'light',
    notifications: true
  }, { session });
});

Update related documents consistently

await session.withTransaction(async () => {
  // Update main document
  await posts.updateOne(
    { _id: postId },
    { 
      $set: { 
        status: 'published',
        publishedAt: new Date()
      }
    },
    { session }
  );
  
  // Update author stats
  await users.updateOne(
    { _id: authorId },
    { $inc: { publishedPosts: 1 } },
    { session }
  );
  
  // Notify subscribers
  await notifications.insertMany(
    subscribers.map(sub => ({
      userId: sub,
      type: 'new_post',
      postId,
      createdAt: new Date()
    })),
    { session }
  );
});

Control what data you read during transactions

session.startTransaction({
  readConcern: { 
    level: 'snapshot' 
  }
});

Control write acknowledgment requirements

session.startTransaction({
  writeConcern: { 
    w: 'majority',
    j: true,
    wtimeout: 5000
  }
});

• Keep transactions short: Under 60 seconds (MongoDB's default timeout)
• Use withTransaction(): It handles retries and rollback automatically
• Set appropriate concerns: Use snapshot + majority for financial operations
• Handle TransientTransactionError: Implement retry logic with exponential backoff
• Index wisely: Ensure queries in transactions use indexes to avoid slowdowns
• Always end sessions: Use try-finally to prevent session leaks
• Test failure scenarios: Simulate crashes, timeouts, and validation errors
• Monitor transaction metrics: Track abort rates and durations

• Don't create large transactions: Avoid updating thousands of documents in one transaction
• Don't forget session parameter: All operations must include { session }
• Don't use transactions unnecessarily: Single document updates are already atomic
• Don't ignore error labels: Check for TransientTransactionError to know if retry is safe
• Don't perform heavy operations: Avoid complex aggregations or large data processing
• Don't mix transaction types: Don't combine regular ops with transaction ops
• Don't use outdated drivers: Use MongoDB driver 4.0+ for full transaction support
• Don't skip testing: Test rollback scenarios thoroughly before production

Basic Transaction (Recommended)

const session = client.startSession();
try {
  await session.withTransaction(async () => {
    // Your operations here
    await collection.updateOne({ ... }, { ... }, { session });
    await collection.insertOne({ ... }, { session });
  });
  console.log('✅ Transaction committed');
} catch (error) {
  console.error('❌ Transaction failed:', error);
} finally {
  await session.endSession();
}

Manual Control with Retry

const session = client.startSession();
try {
  await session.startTransaction({
    readConcern: { level: 'snapshot' },
    writeConcern: { w: 'majority' }
  });
  
  // Operations
  await collection.updateOne({ ... }, { ... }, { session });
  
  // Commit
  await session.commitTransaction();
} catch (error) {
  await session.abortTransaction();
  throw error;
} finally {
  await session.endSession();
}

Transaction Options

const transactionOptions = {
  readConcern: { level: 'snapshot' },
  writeConcern: { 
    w: 'majority',
    j: true,
    wtimeout: 5000
  },
  readPreference: 'primary',
  maxCommitTimeMS: 30000
};

await session.withTransaction(
  async () => { /* operations */ },
  transactionOptions
);

Common Patterns

// Check before update
const doc = await collection.findOne({ _id: id }, { session });
if (!doc) throw new Error('Not found');

// Conditional update
const result = await collection.updateOne(
  { _id: id, balance: { $gte: amount } },
  { $inc: { balance: -amount } },
  { session }
);
if (result.matchedCount === 0) {
  throw new Error('Insufficient balance');
}

// Bulk operations
await collection.bulkWrite([
  { updateOne: { filter: {...}, update: {...} } },
  { insertOne: { document: {...} } }
], { session });