Airbnb

Airbnb's server-driven UI: the Ghost Platform

How Airbnb lets one backend response decide a screen's layout, sections, data, and actions across web, iOS, and Android, and what server-driven UI costs in return.

Based on A Deep Dive into Airbnb's Server-Driven UI System by Ryan Brooks (Airbnb, 29 June 2021).

Also used: Airbnb's Server-Driven UI Platform (InfoQ)

8 min read · Bloom is not affiliated with Airbnb. Read the original for the full story.

TL;DR

  • Airbnb's Ghost Platform (GP) is a server-driven UI system: the backend sends not just data, but the structure of the screen and what interactions do.
  • Screens are built from reusable sections placed into layouts; actions describe what happens when users interact.
  • A shared GraphQL schema (served through Airbnb's Viaduct data layer) gives web, iOS, and Android the same strongly typed models.
  • The payoff is shipping UI changes on all platforms at once without waiting for app releases; the cost is a strict schema and client frameworks that must be built and maintained.

The problem: three clients, three release cycles

Airbnb ships on web, iOS, and Android. In a traditional, client-driven setup, each app receives data and decides on its own how to display it. That means every UI change is implemented three times, and on mobile it only reaches users after an app release and after they update. Keeping the three experiences consistent is a constant effort.

Server-driven UI (SDUI) flips this: the server sends both the data and a description of how to present it. The clients become renderers of a shared vocabulary of UI building blocks. Airbnb's implementation is called the Ghost Platform (GP), named after its two audiences, Guests and hosts.

The building blocks

The InfoQ write-up of Airbnb's post describes four core concepts:

  • Sections: independent, reusable groups of UI components, like a listing's photo gallery, its amenities, or a booking summary. A section is the unit of reuse.
  • Screens: describe which sections appear and how the screen is presented, including different presentation styles (full page, popup, sheet).
  • Layouts: where sections go, from a single column to multi-column layouts with areas like navigation, main content, and footer.
  • Actions: what happens when a user interacts, such as navigating or triggering an event, also described by the server.

Each section is wrapped in a container that carries a component type, so the same section data can be rendered differently depending on context.

The result, in the article's own summary, is that layout, section arrangement, the data in each section, and the actions users take are all "controlled by a single backend response."

One schema for every client

SDUI only works if every client understands the server's vocabulary exactly. Airbnb uses a single GraphQL schema served through Viaduct, its GraphQL-based data layer, so web, iOS, and Android all get the same strongly typed models.

On each client, a framework turns that response into native UI: it reads the screen and layout, finds the renderer for each section type, places sections into their layout slots, and wires up actions. The source credits the platform's success to two things: a robust, flexible schema, and solid client-side frameworks that render UI from it.

The trade-offs (our analysis)

Airbnb's post focuses on the benefits. If you're considering SDUI, weigh the costs too. These points are general engineering analysis, not claims from the article:

  • The schema becomes a public API. Old app versions stay installed for months, so new section types must degrade gracefully on clients that don't know them, and removing fields needs a deprecation process.
  • Client frameworks are a product. Renderers, layouts, action handlers, and their tests on every platform are a large, ongoing investment.
  • Debugging moves. A UI bug might come from the backend response rather than client code, so you need tooling to inspect and replay responses.
  • Not everything fits. Highly interactive, bespoke screens (rich editors, complex gestures) are often better as client-driven code that SDUI screens link to.

SDUI pays off most for content-heavy, frequently changing screens that must look the same everywhere: search results, listing pages, checkout steps.

  Backend (one response for web, iOS, Android)
  ─────────────────────────────────────────────
  screen: { layout: MultiColumn,
            placements: { nav: [...], main: [S1, S2, S3], footer: [S4] } }
  sections: S1 { type: PHOTO_GALLERY, data }   S2 { type: AMENITIES, data } ...
  actions:  "book" -> { navigate: "/checkout" }

           │ same GraphQL schema (strongly typed models)
     ┌─────┴─────────────┬──────────────────────┐
   Web renderer       iOS renderer         Android renderer
   section type ─▶ component registry ─▶ place into layout slot ─▶ wire actions
Server-driven UI response, rendered by each client (simplified)

Key decisions and trade-offs

DecisionWhyTrade-off
Server describes screens, sections, layouts, and actionsUI changes ship on every platform at once, without app releases.Every client needs a rendering framework, and the response format becomes a long-lived contract.
Sections as the unit of reuseTeams compose screens from shared building blocks, which keeps platforms consistent.Designs that don't fit existing sections need new section types on every client.
One GraphQL schema via ViaductStrongly typed models shared by web, iOS, and Android.Couples the UI system to the GraphQL infrastructure and its evolution rules.

What this means for your frontend

  • On the web you can ship instantly anyway, so the release-cycle benefit is smaller. SDUI still helps when web and native apps must stay consistent.
  • A component registry (type → component) with a safe fallback for unknown types is the core of any SDUI renderer. Never crash on an unknown section.
  • Treat the response schema like an API: version it, generate types from it, and test old clients against new responses.
  • Start small: use SDUI for one high-churn, content-driven screen before turning it into a platform.

Check your understanding

What is the main reason a company like Airbnb adopts server-driven UI?

An old app version receives a section type it doesn't know. What should a well-designed SDUI client do?

Go deeper on Bloom

Explainer written 22 October 2026.