Facade Pattern · Design Patterns

What is the Facade pattern?

Facade means: put one simple, high-level entry point in front of a subsystem made of several classes.

The facade does not replace the subsystem or hide it forever. It takes on the job of knowing how the pieces fit together — the right order to call them in, the right objects to wire up — so callers do not have to.

Unlike Adapter, Facade is not fixing a mismatch between two interfaces. The subsystem’s classes already work fine on their own. The problem is that there are too many of them.

The problem it solves

A home theater has an amplifier, a DVD player, and a projector, each with its own small interface.

class Amplifier:
    def on(self) -> None:
        print("Amplifier on")

    def set_volume(self, level: int) -> None:
        print(f"Volume: {level}")

    def off(self) -> None:
        print("Amplifier off")


class DvdPlayer:
    def on(self) -> None:
        print("DVD player on")

    def play(self, movie: str) -> None:
        print(f"Playing: {movie}")

    def off(self) -> None:
        print("DVD player off")


class Projector:
    def on(self) -> None:
        print("Projector on")

    def wide_screen_mode(self) -> None:
        print("Widescreen mode")

    def off(self) -> None:
        print("Projector off")


# without a facade, every caller repeats this:
projector.on()
projector.wide_screen_mode()
amplifier.on()
amplifier.set_volume(5)
dvd_player.on()
dvd_player.play("Inception")

public class Amplifier {
    public void on() { System.out.println("Amplifier on"); }
    public void setVolume(int level) { System.out.println("Volume: " + level); }
    public void off() { System.out.println("Amplifier off"); }
}

public class DvdPlayer {
    public void on() { System.out.println("DVD player on"); }
    public void play(String movie) { System.out.println("Playing: " + movie); }
    public void off() { System.out.println("DVD player off"); }
}

public class Projector {
    public void on() { System.out.println("Projector on"); }
    public void wideScreenMode() { System.out.println("Widescreen mode"); }
    public void off() { System.out.println("Projector off"); }
}

// without a facade, every caller repeats this:
projector.on();
projector.wideScreenMode();
amplifier.on();
amplifier.setVolume(5);
dvdPlayer.on();
dvdPlayer.play("Inception");

type Amplifier struct{}

func (a Amplifier) On()              { fmt.Println("Amplifier on") }
func (a Amplifier) SetVolume(l int)  { fmt.Println("Volume:", l) }
func (a Amplifier) Off()             { fmt.Println("Amplifier off") }

type DvdPlayer struct{}

func (d DvdPlayer) On()           { fmt.Println("DVD player on") }
func (d DvdPlayer) Play(m string) { fmt.Println("Playing:", m) }
func (d DvdPlayer) Off()          { fmt.Println("DVD player off") }

type Projector struct{}

func (p Projector) On()             { fmt.Println("Projector on") }
func (p Projector) WideScreenMode() { fmt.Println("Widescreen mode") }
func (p Projector) Off()            { fmt.Println("Projector off") }

// without a facade, every caller repeats this:
projector.On()
projector.WideScreenMode()
amplifier.On()
amplifier.SetVolume(5)
dvdPlayer.On()
dvdPlayer.Play("Inception")

class Amplifier {
  on() { console.log('Amplifier on'); }
  setVolume(level: number) { console.log(`Volume: ${level}`); }
  off() { console.log('Amplifier off'); }
}

class DvdPlayer {
  on() { console.log('DVD player on'); }
  play(movie: string) { console.log(`Playing: ${movie}`); }
  off() { console.log('DVD player off'); }
}

class Projector {
  on() { console.log('Projector on'); }
  wideScreenMode() { console.log('Widescreen mode'); }
  off() { console.log('Projector off'); }
}

// without a facade, every caller repeats this:
projector.on();
projector.wideScreenMode();
amplifier.on();
amplifier.setVolume(5);
dvdPlayer.on();
dvdPlayer.play('Inception');

That is fine to write once. It is a problem the second, third, and tenth time it is written, because the correct order now lives in every call site instead of one place.

How it works

A facade sits in front of the subsystem, holds references to its pieces, and exposes a small number of high-level methods that coordinate internally.

class HomeTheaterFacade:
    def __init__(self, amplifier: Amplifier, dvd_player: DvdPlayer, projector: Projector) -> None:
        self._amplifier = amplifier
        self._dvd_player = dvd_player
        self._projector = projector

    def watch_movie(self, movie: str) -> None:
        self._projector.on()
        self._projector.wide_screen_mode()
        self._amplifier.on()
        self._amplifier.set_volume(5)
        self._dvd_player.on()
        self._dvd_player.play(movie)

    def end_movie(self) -> None:
        self._dvd_player.off()
        self._amplifier.off()
        self._projector.off()


# use
theater = HomeTheaterFacade(Amplifier(), DvdPlayer(), Projector())
theater.watch_movie("Inception")
theater.end_movie()

public class HomeTheaterFacade {
    private final Amplifier amplifier;
    private final DvdPlayer dvdPlayer;
    private final Projector projector;

    public HomeTheaterFacade(Amplifier amplifier, DvdPlayer dvdPlayer, Projector projector) {
        this.amplifier = amplifier;
        this.dvdPlayer = dvdPlayer;
        this.projector = projector;
    }

    public void watchMovie(String movie) {
        projector.on();
        projector.wideScreenMode();
        amplifier.on();
        amplifier.setVolume(5);
        dvdPlayer.on();
        dvdPlayer.play(movie);
    }

    public void endMovie() {
        dvdPlayer.off();
        amplifier.off();
        projector.off();
    }
}

// use
HomeTheaterFacade theater = new HomeTheaterFacade(new Amplifier(), new DvdPlayer(), new Projector());
theater.watchMovie("Inception");
theater.endMovie();

type HomeTheaterFacade struct {
	Amplifier Amplifier
	DvdPlayer DvdPlayer
	Projector Projector
}

func (h HomeTheaterFacade) WatchMovie(movie string) {
	h.Projector.On()
	h.Projector.WideScreenMode()
	h.Amplifier.On()
	h.Amplifier.SetVolume(5)
	h.DvdPlayer.On()
	h.DvdPlayer.Play(movie)
}

func (h HomeTheaterFacade) EndMovie() {
	h.DvdPlayer.Off()
	h.Amplifier.Off()
	h.Projector.Off()
}

// use
theater := HomeTheaterFacade{Amplifier{}, DvdPlayer{}, Projector{}}
theater.WatchMovie("Inception")
theater.EndMovie()

class HomeTheaterFacade {
  constructor(
    private amplifier: Amplifier,
    private dvdPlayer: DvdPlayer,
    private projector: Projector,
  ) {}

  watchMovie(movie: string) {
    this.projector.on();
    this.projector.wideScreenMode();
    this.amplifier.on();
    this.amplifier.setVolume(5);
    this.dvdPlayer.on();
    this.dvdPlayer.play(movie);
  }

  endMovie() {
    this.dvdPlayer.off();
    this.amplifier.off();
    this.projector.off();
  }
}

// use
const theater = new HomeTheaterFacade(new Amplifier(), new DvdPlayer(), new Projector());
theater.watchMovie('Inception');
theater.endMovie();

Callers do not need to know that a projector needs widescreen mode enabled, or that the volume needs setting before the DVD starts — they just ask to watch a movie. Notice Amplifier, DvdPlayer, and Projector did not change at all.

Worked example: an order-processing facade

A checkout flow that has to touch inventory, payment, and shipping in a specific order, with rollback if something fails partway through.

class InventoryService:
    def check_availability(self, product_id: str, quantity: int) -> bool:
        return True

    def reserve_items(self, product_id: str, quantity: int) -> None:
        pass

    def release_items(self, product_id: str, quantity: int) -> None:
        pass


class PaymentService:
    def process_payment(self, card_number: str, amount: float) -> bool:
        return True


class ShippingService:
    def schedule_shipping(self, address: str, product_id: str) -> None:
        pass


class OrderFacade:
    def __init__(self, inventory: InventoryService, payment: PaymentService, shipping: ShippingService) -> None:
        self._inventory = inventory
        self._payment = payment
        self._shipping = shipping

    def place_order(self, product_id: str, quantity: int, card_number: str, amount: float, address: str) -> str:
        if not self._inventory.check_availability(product_id, quantity):
            return "Item out of stock"

        self._inventory.reserve_items(product_id, quantity)

        if not self._payment.process_payment(card_number, amount):
            self._inventory.release_items(product_id, quantity)
            return "Payment failed"

        self._shipping.schedule_shipping(address, product_id)
        return "Order placed"


# use
orders = OrderFacade(InventoryService(), PaymentService(), ShippingService())
result = orders.place_order("SKU-1", 2, "4111111111111111", 39.98, "221B Baker Street")

public class InventoryService {
    public boolean checkAvailability(String productId, int quantity) {
        return true;
    }

    public void reserveItems(String productId, int quantity) {}

    public void releaseItems(String productId, int quantity) {}
}

public class PaymentService {
    public boolean processPayment(String cardNumber, double amount) {
        return true;
    }
}

public class ShippingService {
    public void scheduleShipping(String address, String productId) {}
}

public class OrderFacade {
    private final InventoryService inventory;
    private final PaymentService payment;
    private final ShippingService shipping;

    public OrderFacade(InventoryService inventory, PaymentService payment, ShippingService shipping) {
        this.inventory = inventory;
        this.payment = payment;
        this.shipping = shipping;
    }

    public String placeOrder(String productId, int quantity, String cardNumber, double amount, String address) {
        if (!inventory.checkAvailability(productId, quantity)) {
            return "Item out of stock";
        }

        inventory.reserveItems(productId, quantity);

        if (!payment.processPayment(cardNumber, amount)) {
            inventory.releaseItems(productId, quantity);
            return "Payment failed";
        }

        shipping.scheduleShipping(address, productId);
        return "Order placed";
    }
}

// use
OrderFacade orders = new OrderFacade(new InventoryService(), new PaymentService(), new ShippingService());
String result = orders.placeOrder("SKU-1", 2, "4111111111111111", 39.98, "221B Baker Street");

type InventoryService struct{}

func (i InventoryService) CheckAvailability(productID string, quantity int) bool { return true }
func (i InventoryService) ReserveItems(productID string, quantity int)          {}
func (i InventoryService) ReleaseItems(productID string, quantity int)          {}

type PaymentService struct{}

func (p PaymentService) ProcessPayment(cardNumber string, amount float64) bool { return true }

type ShippingService struct{}

func (s ShippingService) ScheduleShipping(address, productID string) {}

type OrderFacade struct {
	Inventory InventoryService
	Payment   PaymentService
	Shipping  ShippingService
}

func (o OrderFacade) PlaceOrder(productID string, quantity int, cardNumber string, amount float64, address string) string {
	if !o.Inventory.CheckAvailability(productID, quantity) {
		return "Item out of stock"
	}

	o.Inventory.ReserveItems(productID, quantity)

	if !o.Payment.ProcessPayment(cardNumber, amount) {
		o.Inventory.ReleaseItems(productID, quantity)
		return "Payment failed"
	}

	o.Shipping.ScheduleShipping(address, productID)
	return "Order placed"
}

// use
orders := OrderFacade{InventoryService{}, PaymentService{}, ShippingService{}}
result := orders.PlaceOrder("SKU-1", 2, "4111111111111111", 39.98, "221B Baker Street")

class InventoryService {
  checkAvailability(productId: string, quantity: number) {
    return true;
  }

  reserveItems(productId: string, quantity: number) {}

  releaseItems(productId: string, quantity: number) {}
}

class PaymentService {
  processPayment(cardNumber: string, amount: number) {
    return true;
  }
}

class ShippingService {
  scheduleShipping(address: string, productId: string) {}
}

class OrderFacade {
  constructor(
    private inventory: InventoryService,
    private payment: PaymentService,
    private shipping: ShippingService,
  ) {}

  placeOrder(productId: string, quantity: number, cardNumber: string, amount: number, address: string) {
    if (!this.inventory.checkAvailability(productId, quantity)) {
      return 'Item out of stock';
    }

    this.inventory.reserveItems(productId, quantity);

    if (!this.payment.processPayment(cardNumber, amount)) {
      this.inventory.releaseItems(productId, quantity);
      return 'Payment failed';
    }

    this.shipping.scheduleShipping(address, productId);
    return 'Order placed';
  }
}

// use
const orders = new OrderFacade(new InventoryService(), new PaymentService(), new ShippingService());
const result = orders.placeOrder('SKU-1', 2, '4111111111111111', 39.98, '221B Baker Street');

If the order of operations ever needs to change, there is exactly one method to update, and every caller benefits automatically.

When it helps

Reach for Facade when a subsystem has grown enough moving parts that using it correctly means remembering a sequence or wiring several objects together. It is especially valuable at the boundary between layers — a controller talking to several services, or app code talking to a complex third-party SDK.

Facade also helps when you want to restructure what is underneath later, since callers depend on the facade’s interface, not on the subsystem’s classes directly.

When it hurts

Do not build a facade for two or three classes that are already simple to use together.

Its job is to delegate and coordinate, not to accumulate business logic of its own. A facade that grows validation rules and branching logic is turning into a god object — exactly the complexity Facade was supposed to prevent. Also avoid exposing getters for the internal services just to let callers reach around the facade; that quietly gives up the decoupling that was the whole point.

Practical tips

Give the facade a small number of high-level, task-shaped methods, not a thin pass-through for every subsystem method.
Let the facade delegate — each method should be a sequence of calls in the right order, not new logic.
Document what each facade method does end to end.
Do not confuse Facade with Adapter: Facade assumes the subsystem’s interfaces already work; Adapter exists because two interfaces do not match.

Check your understanding

What is Facade, in one sentence?
A class that provides one simple entry point in front of a subsystem made of several classes, hiding the coordination needed to use them correctly.

How is Facade different from Adapter?
Adapter reconciles two interfaces that do not match. Facade simplifies access to a subsystem whose interfaces already work but has too many pieces to use comfortably.

Does Facade replace the subsystem classes?
No. The subsystem classes stay exactly as they are; the facade sits in front of them.

What is the biggest risk when building a facade?
Letting it absorb business logic and become a god object, instead of staying a thin layer that delegates.

What to learn next

Next: Proxy Pattern — also stands in front of another object, but controls access to one instead of simplifying access to many.