This lesson follows Decorator. A facade offers a simpler interface instead of another interchangeable layer.

Facade gives clients a focused entry point to a complex subsystem. It knows the objects and call order required to complete a common task. That reduces client coupling, but the facade itself becomes coupled to those details.

Name the operation the client wants

An upload page needs a thumbnail. The media library exposes a decoder, a resizer, and an encoder. Every caller currently chooses their settings, orders their calls, and releases the decoded image. A library upgrade now touches every upload flow.

interface ImageHandle { close(): void }
interface Decoder { decode(bytes: Uint8Array): ImageHandle }
interface Resizer { resize(image: ImageHandle, width: number): void }
interface Encoder { png(image: ImageHandle): Uint8Array }

class ThumbnailFacade {
  constructor(
    private decoder: Decoder,
    private resizer: Resizer,
    private encoder: Encoder,
  ) {}
  thumbnail(bytes: Uint8Array): Uint8Array {
    const image = this.decoder.decode(bytes);
    try {
      this.resizer.resize(image, 160);
      return this.encoder.png(image);
    } finally {
      image.close();
    }
  }
}

The subsystem interfaces are illustrative. Resize mutates the owned image, and png returns independent output bytes. The facade owns cleanup after decode succeeds. Its client does not need to know these details.

Trace the hidden orchestration

Keep the entry point focused

Subsystem classes normally do not know the facade exists. They can still interact directly. A facade is not automatically an enforcement boundary that prevents every direct call. An architecture can impose that extra rule when useful.

Map the roles

Role	In this example	Job
Facade	ThumbnailFacade	Gives convenient access to part of a subsystem. Knows where to direct each request and how to operate the moving parts.
Additional facade	for example a separate VideoPreviewFacade	Keeps unrelated features out of one facade so it does not grow into another complex structure. Clients and other facades can use it.
Complex subsystem	Decoder, Resizer, Encoder	Dozens of objects that need the right order and the right data to do useful work. They do not know the facade exists and still talk to each other directly.
Client	the upload page	Calls the facade instead of the subsystem objects

Reach for it when clients need a simple door into a complex subsystem

• you need a limited but straightforward interface to a complex subsystem. Subsystems grow more complex over time, and even well-designed ones need more setup and boilerplate. A facade gives shortcuts to the features most clients need.
• you want to structure a subsystem into layers. Give each layer a facade as its entry point, and require layers to talk to each other only through those facades. That cuts coupling between them, much like Mediator.

Implement it in five steps

Refactor existing code toward the pattern in this order:

1. Check whether a simpler interface than the subsystem's own is possible. You are on the right track if it makes client code independent of many subsystem classes.
2. Declare and implement that interface in a new facade class. The facade redirects calls from client code to the right subsystem objects.
3. If client code does not already initialize the subsystem and manage its life cycle, make the facade do it.
4. To get the full benefit, make all client code talk to the subsystem only through the facade. Subsystem changes, such as a library upgrade, then only touch the facade.
5. If the facade grows too big, extract part of its behavior into a new, more focused facade class.

Name what it costs

You gain	You pay
Your code is isolated from a complex subsystem	The facade can become a god object coupled to every class in the app
A reusable configuration and life cycle sequence	The simplified API exposes only selected capabilities
Clear boundaries between subsystem layers	The facade must track subsystem changes

Do not confuse it with its neighbors

Pattern	How it relates
Adapter	Facade defines a new interface for existing objects. Adapter makes an existing interface usable. Adapter usually wraps one object. Facade covers a whole subsystem.
Abstract Factory	When you only need to hide how the subsystem creates its objects, an abstract factory can replace a facade.
Flyweight	Flyweight shows how to make many small objects. Facade shows how to make one object that represents a whole subsystem.
Mediator	Both organize collaboration among tightly coupled classes. A facade adds no new behavior, and the subsystem does not know about it. A mediator centralizes communication, and components know only the mediator.
Singleton	One facade object is usually enough, so a facade is often a singleton.
Proxy	Both buffer a complex entity and can initialize it. A proxy has the same interface as its service, so the two are interchangeable. A facade does not.

Retrieve and apply

Describe a facade for a library used by several callers. State its useful operation and resource owner. Continue to Flyweight to share repeated immutable state.