Loading...
System Design and AI Engineering, by Roni Das. 974 interactive lessons.
Start LearningIntermediate · Microservices Architecture
A structural design pattern that puts one simple interface in front of a complicated set of classes or services, so callers make one call instead of coordinating many.
In short
The facade pattern is a structural design pattern that puts one simple interface in front of a complicated subsystem, so a caller makes one call instead of coordinating many classes. It adds no new capability, and the subsystem stays reachable for callers who need fine control.
In short
The facade pattern is a structural design pattern that puts one simple interface in front of a complicated subsystem, so a caller makes one call instead of coordinating many classes. It adds no new capability, and the subsystem stays reachable for callers who need fine control.
This page is the free part.
₹499 in India$49 everywhere elseonce, for the whole course
The System Design course covers Facade Pattern across a run of lessons, not one page. These 4 alone are about 69 minutes of step-by-step reading, every one with a quiz.
Simplify complex subsystems by providing a unified interface, the front desk of your software architecture.
Add responsibilities to objects dynamically by wrapping them, like middleware for your classes.
Control access to an object by placing a surrogate in front of it, caching, security, and lazy loading in one pattern.
Make incompatible interfaces work together, the universal translator of software architecture.
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 Facade Patternpay once,
yours for life
A subsystem is a group of classes that work together on one job, such as playing a video. Each class does its own part, and they must be called in the right order. A caller that uses them directly has to know all of them.
The Gang of Four intent for Facade is: provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.
The lesson explains it with a hotel. You need a room, a dinner booking, a wake-up call and a taxi. Without help you would visit four departments in four buildings. Instead you go to the front desk, and one person calls each department in the right order. The front desk is the facade.
Facade is a structural pattern, like Adapter, Decorator and Proxy. See structural design patterns for the group and design patterns for the whole catalogue.
The lesson uses a media player. Playing one file needs several classes: a video decoder, an audio decoder, a subtitle parser and, in the lesson's table, a buffer manager and a display renderer.
Without a facade, the client creates and manages all of those objects. It handles each one's lifecycle and each one's errors. Any change inside the subsystem can break the client.
With a facade, the client calls MediaPlayer.play(file). The facade calls the decoders and the parser in the correct order and returns when the file is ready. The client manages one object and one method call.
Drawn from the lesson Facade Pattern.
Two details in the picture matter. First, the facade only coordinates. Every real piece of work is still done by the subsystem classes. Second, the dashed arrow from the advanced client goes around the facade. The lesson is clear that a facade does not hide the subsystem. It offers a shortcut for the common case and leaves the rest open.
The lesson's key rule: a facade does not add new functionality. It reorganises what already exists into a simpler interface. It is about convenience, not capability.
The lesson lists familiar facades. The AWS SDK call s3.upload(params) hides multipart upload, checksums, retries and progress tracking. jQuery's $.ajax() wrapped the verbose XMLHttpRequest API. And kubectl apply -f deployment.yaml sits in front of the Kubernetes API server. Behind it run validation, admission control and the reconciliation loop.
The same idea works between services. In the lesson's sequence, a mobile app makes one request, GET /homepage, to an API gateway. The gateway calls three services in parallel: the user service for the profile, the order service for the three most recent orders, and the recommendation service for five top picks. It stitches the answers into one response.
Without that facade, the phone would make three separate round trips. Each one costs radio time and battery.
A gateway built for one kind of client is called a backend for frontend, or BFF. The lesson calls it the Facade pattern at infrastructure scale. Each client type, such as an iOS app, an Android app or a TV app, can get its own BFF that shapes the data the way that client needs it.
All three sit between other things, but each has a different goal. The lesson puts it in three verbs.
Real systems mix them. The lesson's example is an API gateway that is all three at once. It simplifies backend calls like a facade, translates REST to gRPC like an adapter, and routes between services like a mediator. The pattern names describe intent, not separate boxes.
A related wrapper is the proxy pattern. A proxy keeps the same interface as one object and controls access to it, while a facade creates a new, simpler interface over many objects.
Skip a facade when clients really need fine control over the subsystem. Forcing everyone through a simple path then gets in the way. Also skip it when the facade would only move complexity rather than reduce it.
Use one when most callers need only a few common operations. Use one to stop your code depending on a third-party library directly. And use one when each layer of a system should have a single entry point.
To step through the media player flow and the gateway sequence, the Facade Pattern lesson is the next step.
AWS SDK s3.upload
The lesson's example of a library facade: one method hides multipart upload, checksums, retries and progress tracking.
API gateway for a mobile homepage
The lesson's sequence: one GET /homepage call fans out to user, order and recommendation services and returns one combined response.
It is a structural pattern that gives a complex subsystem one simple front. The caller makes one call, such as play(file), and the facade calls the subsystem classes in the right order. It adds no new capability, and callers can still use the subsystem directly when they need to.
They solve different problems. A factory is a creational pattern: it decides which concrete object to build and returns it behind an interface. A facade is a structural pattern: it puts one simple interface in front of many objects that already exist. A facade may use a factory inside it, but the two are not alternatives.
The Gang of Four book sorts its 23 patterns into creational, structural and behavioral. Creational patterns, such as Factory and Singleton, deal with how objects are made. Structural patterns, such as Facade and Adapter, deal with how objects are combined. Behavioral patterns, such as Strategy and Observer, deal with how objects share work.
Yes, in intent. A gateway that turns one client request into calls to several backend services and returns one response is a facade at infrastructure scale. Many gateways also translate protocols and route traffic, so they act as an adapter and a mediator at the same time.
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.
Adapter Pattern
A structural design pattern that wraps a class with an incompatible interface so it matches the interface your code expects, like a travel plug adapter for software.
API Gateway
A single entry point for all client requests that routes them to the appropriate microservice. Handles auth, rate limiting, and request transformation.
Backend for Frontend (BFF)
A dedicated backend service tailored for a specific frontend (mobile, web, TV). Each frontend gets an API shaped to its exact needs instead of sharing one generic API.
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 "Facade 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 Facade Pattern lessoncourse 1
From absolute beginner to principal engineer, drawn step by step.