Loading...
System Design and AI Engineering, by Roni Das. 974 interactive lessons.
Start LearningIntermediate · Microservices Architecture
A structural design pattern that puts a stand-in object with the same interface in front of a real object to control access to it, for example to cache, check permissions or load it lazily.
In short
The proxy pattern, or proxy design pattern, is a structural pattern where a stand-in object with the same interface sits in front of a real object and controls access to it. The client cannot tell the difference, while the proxy caches results, checks permissions, logs calls or delays loading.
In short
The proxy pattern, or proxy design pattern, is a structural pattern where a stand-in object with the same interface sits in front of a real object and controls access to it. The client cannot tell the difference, while the proxy caches results, checks permissions, logs calls or delays loading.
This page is the free part.
₹499 in India$49 everywhere elseonce, for the whole course
The System Design course covers Proxy Pattern across a run of lessons, not one page. These 4 alone are about 68 minutes of step-by-step reading, every one with a quiz.
Control access to an object by placing a surrogate in front of it, caching, security, and lazy loading in one pattern.
Attaching permission lists directly to resources, who can do what to this specific object.
Assigning permissions to roles instead of individuals, the most widely used access control model in production systems.
Restricting access based on time windows, business hours, maintenance windows, temporary grants, and expiring permissions.
all part of
System Design Masterclass
770 lessons · about 283 hours · 18 free to read
₹499in India, by UPI
$49everywhere else, by PayPal
Ive started this course by accident - LLM advised me this site. When I passed few free lessons, I had no doubt - this course should be bought. And I did it with special pleasent price and it was best decision of the month. Content is great, interesting to read and with a lot of practial cases (what makes it different from other souces and books) I hope to teach all the lessons, that will be my supergoal. Glad that I found this resource and speacial Thank You to Roni Das - Great Job!
You own this course
Continue with Proxy Patternpay once,
yours for life
The Gang of Four intent for Proxy is: provide a surrogate or placeholder for another object to control access to it. A surrogate is a stand-in that takes the place of something else.
The key is the interface. The proxy implements exactly the same interface as the real object, often called the real subject. So the client calls the proxy as if it were the real thing. The proxy does its own work first, such as a cache lookup or a permission check. Then it decides whether to forward the call to the real object.
One note on the name. This page is about the proxy as an object-oriented design pattern inside your code. A proxy server on a network, such as a forward proxy or a reverse proxy, is covered on the proxy page. The idea is the same, a stand-in in the middle, but the scale is different.
Proxy is a structural pattern. See structural design patterns for its group and design patterns for the full catalogue.
The lesson opens with an e-commerce team whose Postgres CPU sat at 98 percent at peak. The cause was one product catalog query. It ran 50,000 times per minute, but the catalog changed about once a day.
The fix was a caching proxy with the same method, getProducts(). The proxy checked Redis first. On a hit it returned in 0.3 ms. On a miss it queried Postgres, stored the result with a 60-second TTL, and returned it. TTL, or time to live, is how long a cached copy is kept before it expires.
In the lesson's story, database CPU fell from 98 percent to 12 percent. Response times dropped from 45 ms to under 2 ms for 92 percent of requests. No caller changed a line of code, because the interface did not change.
The lesson sends two requests through the same proxy. The proxy does three things on every call: an auth check, a cache lookup and an access log.
Drawn from the lesson Proxy Pattern.
Look at the client in the picture. It has one arrow, to the interface. It does not know whether the proxy or the real service answered. That is what separates a proxy from a cache bolted onto the caller: the caller stays exactly the same.
The Gang of Four describe remote, virtual and protection proxies, plus a smart reference that does extra work on each access. The lesson lists five flavours in modern terms.
In production these concerns are often stacked as layers. The lesson orders them: auth first, so bad tokens fail fast. Caching second, so hits return early. Logging third. Forwarding to the real service last, only on a miss. Each layer has one job, so you can add, remove or reorder layers without touching the others.
All four structural patterns wrap something. The difference is intent.
The proxy and decorator line is blurry in practice, and the lesson says so. A sidecar proxy in a service mesh, such as Envoy, caches, controls access and adds behaviour all at once. In an interview, name the intent: access control means proxy, added behaviour means decorator.
A proxy pays for itself when you need cross-cutting behaviour, such as caching, auth, logging or rate limiting, without editing the real object. It also helps when the real object is expensive to create or to reach.
Skip it when the proxy is a thin wrapper that adds nothing. Every hop adds a little latency. Be most careful with caching proxies. If you have no way to expire or purge stale entries, you have traded correctness for speed. See cache invalidation for the usual ways to handle that.
To step through the hit and miss sequence and the layered proxy stack, the Proxy Pattern lesson is the next step.
Caching proxy over a product catalog
The lesson's opening story: a Redis-backed proxy with the same getProducts() method cut database CPU from 98 percent to 12 percent.
gRPC client stubs
A remote proxy, as the lesson lists it: a local object with the service's methods that sends each call over the network.
It is a structural pattern where a stand-in object with the same interface as a real object sits in front of it. The client calls the stand-in, which can cache results, check permissions, log the call or create the real object only when needed. The client cannot tell that a proxy is there.
Start from the problem, not the pattern. If you need to control access to one object without changing its interface, use a proxy. If you need to make an incompatible interface fit, use an adapter. If you need to simplify many classes, use a facade, and if you need to add behaviour while keeping the interface, use a decorator. If there is no real problem yet, use no pattern.
Both keep the same interface as the object they wrap. A proxy controls access, deciding whether and how the call reaches the real object. A decorator adds functionality around a call that always goes through, and decorators are often stacked.
Not quite. The design pattern is an object inside your code that stands in for another object. A proxy server is a separate machine or process that stands in for clients or servers on a network. A caching reverse proxy follows the same idea at network scale.
Design Patterns
Named, reusable solutions to problems that keep coming up in object-oriented code, such as creating objects, wrapping interfaces or reacting to events. The classic catalogue of 23 was published by the Gang of Four in 1994.
Decorator Pattern
A structural design pattern that wraps an object in another object with the same interface to add behavior, such as logging, caching or retries, without changing the original class.
Proxy
An intermediary server that sits between the client and the destination server. Forward proxies act on behalf of clients; reverse proxies act on behalf of servers.
Reverse Proxy
A server in front of your web servers that receives every request first, passes it to one of them and returns the answer. It handles TLS, load balancing, caching and routing, and hides the servers behind it.
Microservices
An architecture where an application is split into small, independent services that communicate over the network. Each service owns its own data and can be deployed separately.
Monolith
A single, unified application where all features share the same codebase and deployment. Simpler to start with but harder to scale individual parts.
This page explains the idea. The "Proxy Pattern" lesson builds it up step by step, with diagrams. It is part of the System Design Masterclass course, which has 770 lessons. 18 of them are free to read. You pay once and keep it for life, with no subscription.
Open the Proxy Pattern lessoncourse 1
From absolute beginner to principal engineer, drawn step by step.