Real Failure Scenarios Without Load Balancing
Picture this: at peak load, your mobile app handles 10,000 requests per second. A single server can't keep up—users get 401 errors after login, chat connections drop. The problem often isn't the code, but how traffic is distributed across backend instances. Misconfigured sessions, health checks, or WebSocket proxies lead to logouts, disconnects, and performance degradation. Our engineers, with over 10 years in mobile backend production, see this on nearly every other project. Without proper load balancing, even a well-written backend collapses under peak load. This article dives into real scenarios and delivers working configurations.
Why Load Balancing Configuration Matters for Mobile Backends
Mobile apps are particularly sensitive to latency and connection drops. Load balancing distributes traffic evenly, preventing overload on individual servers. For mobile scenarios, WebSocket support (for chat and live updates) and stateless architecture for seamless scaling are critical. Without correct setup, users face logouts and data loss.
How to Avoid Session Loss During Balancing
A mobile client logs in and receives a JWT. The next request hits a different pod—if tokens are stored in memory instead of Redis, the user gets logged out. This is a real scenario with stateful sessions lacking a centralized store. The fix: stateless service + JWT + Redis for shared state.
Another issue: WebSocket connections. A long-lived chat or live-tracking connection must always land on the same pod. If the balancer terminates a WebSocket during a pod deployment, all active connections drop simultaneously.
How to Balance REST API and WebSocket
For most REST APIs, L7 balancing (HTTP/HTTPS) suffices. We use Nginx, HAProxy, AWS ALB, or Google Cloud Load Balancing. For stateless services, we prefer Round Robin; for heavy requests (file uploads, complex aggregations), Least Connections.
Why Avoid Sticky Sessions?
Binding a user to a pod via SERVERID cookie or IP hash kills horizontal scalability. If that pod fails, the user is cut off. The better approach: stateless service + JWT + Redis for shared state.
Configuring WebSocket Through a Load Balancer
For Nginx: proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "upgrade";. AWS ALB supports WebSocket natively. Set timeout explicitly (proxy_read_timeout 3600s), or Nginx closes idle connections after 60 seconds.
Why Health Check Must Verify the Database
A dedicated endpoint /health/ready should check connections to the database, Redis, and external dependencies. The balancer removes a pod after two consecutive failures and returns it after two successful responses.
Why Health Check Must Be Ready
One reason: GET / may return 200 even when the database is unresponsive. Lack of dependency checks leads to cascading failures. Example: peak load of 8000 rps at lunch, one instance at 80% CPU. We added balancing across 3 pods via AWS ALB and configured /api/health/ready checking PostgreSQL. After the first deployment without the balancer: 20 seconds of downtime (old pod killed, new pod not yet passing health check). After setting minReadySeconds: 30 and rolling update with maxUnavailable: 0—zero downtime on subsequent 50+ deployments.
Configuring Load Balancing via Kubernetes Ingress
In Kubernetes, balancing happens at the Service level (kube-proxy, iptables/IPVS) plus Ingress controller. Ingress-NGINX is the standard: it supports WebSocket, rate limiting via nginx.ingress.kubernetes.io/limit-rps annotation, and upstream hashing. kube-proxy in IPVS mode instead of iptables: with 1000+ services, iptables becomes linear; IPVS is O(1). Enable via --proxy-mode=ipvs. According to Kubernetes documentation, IPVS provides better scalability with many services.
Tool Comparison
| Tool | Protocols | Sticky Sessions | WebSocket | Health Check |
|---|---|---|---|---|
| Nginx | L4/L7 | Yes (cookie/IP hash) | Yes | Yes (active) |
| HAProxy | L4/L7 | Yes (cookie) | Yes | Yes (active) |
| AWS ALB | L7 | Yes (cookie) | Yes | Yes (active) |
| GCP LB | L7 | Yes (cookie) | Yes | Yes (active) |
Algorithm Comparison
| Algorithm | Characteristics | When to Use | Throughput |
|---|---|---|---|
| Round Robin | Even distribution | Stateless services, short requests | 10,000 rps per pod |
| Least Connections | Sends to least loaded | Uneven load, heavy requests | 8,000 rps per pod |
| IP Hash / Sticky | Binds to IP | Legacy, stateful | 5,000 rps per pod |
Round Robin processes requests 1.5x faster than Least Connections under uniform load.
What's Included in Turnkey Setup
- Audit of current backend architecture.
- Selection and deployment of load balancer (Nginx/HAProxy/Ingress).
- Configuration of health check endpoints.
- WebSocket proxy setup.
- Optimization of distribution algorithms.
- Operations and monitoring documentation.
- Guarantee of zero-downtime deployments when recommendations are followed.
Timeline: basic setup—1–2 days. Full solution with Kubernetes Ingress and mTLS—1–2 weeks. We offer a free assessment of your project. Contact us for a consultation.
Over 10 years, we have configured load balancing for 40+ mobile projects with peak loads up to 10,000 rps. We use certified tools and guarantee 99.9% uptime. Nginx is one of the most popular load balancers. Get a free consultation now.