Strategies and Algorithms
Load balancing is a foundational traffic distribution mechanism in distributed systems, responsible for spreading incoming requests or computational work across a pool of servers, nodes, or services to prevent resource saturation and maintain system availability. This page covers the definition and classification of load balancing strategies, the algorithmic mechanics that govern request routing, the operational scenarios where specific approaches excel or fail, and the decision criteria practitioners use to select between competing approaches. The treatment applies to architects, engineers, and researchers working with horizontally scaled infrastructure, microservices environments, and cloud-native deployments.
Definition and scope
Load balancing in distributed systems refers to the process of distributing incoming network traffic, computation tasks, or storage operations across multiple backend resources to optimize resource utilization, maximize throughput, minimize response latency, and avoid overloading any single node. The scope encompasses both network-layer balancing (Layer 4, operating on IP and TCP headers) and application-layer balancing (Layer 7, operating on HTTP headers, URLs, cookies, and content type).
The Internet Engineering Task Force (IETF) documents foundational network protocols — including TCP/IP session behavior (RFC 793) — that underpin all Layer 4 load balancing implementations. At the application layer, HTTP/2 and HTTP/3 session multiplexing, documented in RFC 9113 and RFC 9114 respectively, alter how persistent connections interact with load balancer affinity logic.
Load balancing operates at three broad scopes within a distributed architecture:
- Global server load balancing (GSLB) — distributes traffic across geographically separated data centers or cloud regions, typically using DNS-based routing or Anycast addressing.
- Cluster-level load balancing — distributes requests across nodes within a single data center or availability zone, using dedicated hardware appliances, software proxies, or sidecar proxies within a service mesh.
- Application-internal load balancing — distributes work within a single application across thread pools, connection pools, or internal service replicas, often implemented in client-side libraries or frameworks.
NIST SP 800-145, the NIST definition of cloud computing, treats elastic resource scaling — which depends on effective load distribution — as a core characteristic of cloud service models. Load balancing is the mechanism that makes elasticity operationally viable at runtime.
How it works
A load balancer receives an incoming request and applies a routing algorithm to select a backend destination. The choice of algorithm determines how fairly work is distributed and how well the balancer adapts to heterogeneous backend capacity. The major algorithm classes are:
- Round Robin — routes each successive request to the next server in a fixed sequence. Performs well when all nodes have identical capacity and request processing time is uniform. Fails under heterogeneous load because a slow request on one node delays its utilization even while new requests continue to arrive.
- Weighted Round Robin — extends Round Robin by assigning a numeric weight to each node, proportional to its relative capacity. A node with weight 3 receives 3 requests for every 1 request routed to a node with weight 1. Useful when backend nodes have asymmetric CPU, memory, or network provisioning.
- Least Connections — routes each new request to the node currently handling the fewest active connections. Outperforms Round Robin in environments with variable request duration, such as long-lived WebSocket connections or streaming APIs.
- Least Response Time — combines active connection count with observed response latency, routing to the node with the lowest product of the two metrics. Requires the load balancer to collect real-time health and latency telemetry from backends.
- IP Hash (Session Affinity) — hashes the client IP address to consistently map a given client to the same backend node. Preserves session state without requiring a shared session store, but creates uneven load distribution when a small number of clients generate disproportionate traffic.
- Random with Two Choices (Power of Two Choices) — selects 2 backend nodes at random, then routes to the one with fewer active connections. Research published in the ACM literature demonstrates this reduces maximum load concentration substantially compared to pure random selection while avoiding the coordination overhead of global state tracking.
- Consistent Hashing — maps both requests and nodes onto a hash ring, so adding or removing a node redistributes only a fraction of requests rather than rehashing all assignments. Widely used in distributed caching and distributed data storage contexts, as documented in the original Karger et al. paper published through MIT and cited extensively in ACM proceedings.
Load balancers also perform health checking — sending periodic probes (typically TCP handshakes or HTTP GET requests to a designated health endpoint) to detect node failures. Failed nodes are removed from the routing pool within the health check interval, typically configured between 5 and 30 seconds depending on failure sensitivity requirements. This health-check mechanism directly supports fault tolerance and resilience goals.
The relationship between load balancing and service discovery is structural: before a load balancer can route to a node, it must know the node exists. In dynamic container environments — addressed in detail in the container orchestration reference — service registry updates feed the load balancer's backend pool in near real time.
Common scenarios
Stateless HTTP microservices represent the simplest load balancing scenario. Because no session state is stored on the backend node, any algorithm can be applied without affinity constraints. Least Connections or Weighted Round Robin are standard choices. This is the dominant pattern in microservices architecture deployments.
Stateful session workloads — such as shopping cart services or financial transaction flows — require either IP Hash affinity or externalized session state in a distributed cache. Without affinity or shared state, a request routed to a different node mid-session will fail to find the expected context. Externalizing session state to a shared cache eliminates the affinity dependency and is the preferred engineering approach in high-scale deployments.
Long-lived connections (WebSockets, gRPC streaming) create persistent connection imbalance under Round Robin, because Round Robin distributes connection establishment events evenly but cannot account for connections that remain open for minutes or hours. Least Connections handles this correctly; pure Round Robin creates hotspots. The gRPC and RPC frameworks reference covers the protocol-specific implications in detail.
Database read replicas use load balancing to distribute read queries across replica nodes, reducing primary node load. This intersects directly with replication strategies and consistency models, since load-balanced reads across asynchronous replicas may return stale data depending on replication lag.
Decision boundaries
Selecting a load balancing strategy requires evaluating at least 4 independent dimensions:
- Request homogeneity — if requests have approximately uniform processing cost, Round Robin is sufficient. If cost varies widely (as in a query API serving both trivial lookups and complex aggregations), Least Connections or Least Response Time is required to prevent node saturation.
- Session state model — stateless services have no affinity requirement. Stateful services require either IP Hash or externalized state. The distributed system design patterns reference covers the architectural tradeoffs of each model.
- Backend heterogeneity — identical node provisioning supports uniform algorithms. Mixed-capacity pools (common after incremental hardware upgrades or when combining on-premise nodes with cloud burst capacity) require weighted variants.
- Scale and coordination cost — Least Connections and Least Response Time require the balancer to maintain real-time state about backend nodes, introducing coordination overhead that becomes significant at pools exceeding several hundred nodes. Consistent Hashing and Power of Two Choices reduce coordination requirements.
Layer 4 vs. Layer 7 is the primary classification boundary in load balancer architecture. Layer 4 balancers operate on TCP/UDP headers only — they are faster and simpler but cannot make routing decisions based on request content. Layer 7 balancers inspect HTTP headers, paths, and cookies, enabling path-based routing (e.g., routing /api/v2/ to one backend pool and /static/ to another), A/B traffic splitting, and protocol-aware health checks. The overhead of Layer 7 inspection adds latency on the order of sub-millisecond to low single-digit milliseconds per request, a cost that is acceptable in most applications but material in ultra-low-latency financial or real-time control systems.
Latency and throughput targets — documented in system SLAs — are the operational anchors for this tradeoff. Systems with 99th-percentile latency targets below 10 milliseconds typically restrict Layer 7 load balancing to edge entry points and use Layer 4 or client-side balancing internally. The broader structural principles governing how distributed systems handle these tradeoffs are mapped in the Distributed Systems Authority index.