Most of us interact with reverse proxies every day, whether through API gateways, ingress controllers, load balancers, or edge services. At first glance, a reverse proxy appears deceptively simple: receive a request, forward it to a backend service, and return a response.
In reality, reverse proxies sit at the heart of modern infrastructure and are responsible for much more than just request forwarding. As traffic scales and production requirements emerge, the seemingly simple functionality evolves into a series of engineering challenges involving networking, reliability, security, observability and performance.
Consider a few common scenarios:
How does a proxy decide which backend should receive the next incoming request?
What happens when a backend instance becomes unhealthy?
How does TLS termination work at scale?
How can operators understand why requests are slow?
These problems are solved by open-source projects such as NGINX, Envoy, and HAProxy. But understanding how these systems are designed requires looking beneath the surface.
In this session, we will explore the architecture of modern reverse proxies using Envoy as a reference architecture. We will follow the lifecycle of a request as it moves through listeners, filter chains all the way to the backend clusters, while understanding the mechanisms that make modern infrastructure reliable, secure, and observable.
What you’ll learn:
Reverse proxy fundamentals
Request lifecycle inside a modern proxy
Listener, filter chain, and cluster architecture
Load balancing and service discovery
Health checking and resiliency patterns
Retries, circuit breakers, and fault tolerance
TLS termination and security layers
Metrics, logging and distributed tracing
By the end of the session, you'll have a better understanding of what happens inside a modern reverse proxy and why projects like Envoy, NGINX, and HAProxy are far more sophisticated than they first appear.
