Course contentsShow
← System Design
Lesson 579 of 1,91916. Distributed TransactionsFree lesson

Performance Overhead of Distributed Transactions

Understanding latency multiplication and throughput reduction from coordinating multiple systems.

Performance Overhead of Distributed Transactions

You'll learn why distributed transactions can dramatically slow down your system and reduce how many operations it can handle.

The Core Problem

When you coordinate a transaction across multiple systems using protocols like Two-Phase Commit (2PC), you're essentially asking several computers to work in lockstep. This coordination creates two major performance problems: latency multiplication and throughput reduction.

Latency Multiplication

In a single-node transaction, you pay the latency cost once. In a distributed transaction, you multiply it:

  • Each phase of 2PC requires a network round trip to all participants
  • The coordinator must wait for the slowest participant to respond
  • If you have 5 participants and each adds 10ms of network latency, you've added 50ms+ just for coordination
  • The overall transaction time becomes the sum of all coordination delays plus the slowest participant's processing time

Analogy: Imagine coordinating a group decision over phone calls. Everyone must agree before proceeding, but you can only call one person at a time. The total time depends on how long the slowest person takes to answer and decide.

Throughput Reduction

Because participants hold locks during the entire 2PC protocol (prepare phase through commit), they block other transactions from accessing the same resources. This creates cascading effects:

  • Resources stay locked longer than in local transactions
  • Other transactions queue up waiting for locks
  • System throughput (operations per second) drops significantly
  • Under high load, the system can grind to a halt

The blocking nature of 2PC makes this worse—if the coordinator fails, participants remain blocked indefinitely until recovery.

Key Takeaway: Distributed transactions trade performance for correctness—expect 10-100x higher latency and dramatically reduced throughput compared to single-node operations, which is why many systems avoid them entirely.