What Is Server-Driven UI on iOS?

Server-driven UI on iOS is an architectural pattern where the backend owns the structure and behavior of screens, sending a structured description of native…

Twisted mineral core with spiralling layers symbolizing the structured core of server-driven UI on iOS.

Server-driven UI on iOS is an architectural pattern where the backend owns the structure and behavior of screens, sending a structured description of native layouts (such as SwiftUI views) that the app renders at runtime instead of hard-coding every interface client-side. In the Uzori context, this extends to AI-influenced screens: an AI agent composes candidate layouts, but the server still validates and approves the final SwiftUI schema before it streams into the app.

How Server-Driven UI Works on iOS

In a server-driven UI (SDUI) system, the iOS app becomes a high-fidelity renderer for layouts described by the backend.

Instead of returning only domain data (products, plans, content), the server also returns UI structure: sections, components, navigation flows, and states. Apollo’s guidance on SDUI describes this as “returning product information from an API instead of domain data,” meaning the server decides how the user experience is shaped.

On native iOS, this fits naturally with SwiftUI’s declarative model. SwiftUI expects you to describe what the interface should look like given some state. In SDUI, that state is a structured payload from the backend: a typed schema that maps cleanly to SwiftUI views such as List, Form, NavigationStack, carousels, and detail cards.

Uzori’s twist is adding an AI composition step in the backend pipeline.

  1. A user issues a request inside your app (for example, “help me configure roaming protection”).
  2. Your backend and Uzori’s engine interpret that intent using LLMs and your existing APIs (often described via OpenAPI).
  3. The AI agent proposes a screen description: a structured layout containing lists, forms, comparison blocks, and multi-step flows.
  4. Your server validates this proposed schema against an allowlisted contract (components, props, actions) and corrects or rejects anything unsafe or invalid.
  5. The validated SwiftUI screen description is streamed back to the app, which renders it natively.

The critical point: the client never executes arbitrary remote code. It renders server-approved SwiftUI structures that fit within a constrained, typed schema. AI helps decide which components to use and how to arrange them, but the backend retains authority over the final shape.

Why Server-Driven UI Matters for AI-Native iOS Apps

Server-driven UI matters because it bridges three conflicting pressures in modern mobile development:

  • Teams want rich, adaptive AI experiences.
  • Users expect polished, native SwiftUI interfaces instead of generic chat boxes.
  • Product leaders need safety, consistency, and the ability to iterate without constant app releases.

Sensor Tower reports that mobile users spent 4.2 trillion hours in apps in the past year, with consumer spend crossing $150 billion. At the same time, generative AI app downloads neared 1.7 billion in H1 2025 and in-app purchase revenue reached nearly $1.9 billion. Those numbers show that the high-value surface for AI is still the native app experience, not just web chat tools.

Classic SDUI helps you update screens without shipping new binaries. AI adds personalization and task intelligence. But unstructured AI output—raw text or free-form JSON—cannot safely drive production UI.

By combining SDUI with an AI engine inside a constrained schema, Uzori lets you:

  • Compress weeks of UI iteration into a runtime system where AI designs flows and the server validates them.
  • Keep everything native: SwiftUI screens perform and feel like the rest of your app, including accessibility and design system alignment.
  • Ship AI-first features faster: one assistant surface can support many wizards, product explorers, comparison views, and concierge flows without hand-coding each one.

If you want a deeper architectural walkthrough, see the related guide: how server-driven UI on iOS turns AI answers into native SwiftUI in real time.

How Uzori Implements Server-Driven UI on iOS

Uzori treats server-driven UI as the interface layer for AI agents rather than just a generic layout system.

Typed SwiftUI Schema

Uzori defines a constrained, typed schema for SwiftUI screens. Each component—lists, forms, carousels, detail cards, navigation steps—has a known shape and allowable properties.

This schema is implemented in the Uzori iOS SDK as a set of native SwiftUI renderers. The app integrates a single screen that can display any server-described layout, but every layout still maps to familiar SwiftUI views and patterns.

AI Agents Emit Structured Layouts

Instead of answering with paragraphs, AI agents in Uzori’s engine emit structured layouts that match this schema.

For example, a request like “show me evening gowns under $300 and help me compare them” might lead the AI to propose:

  • A filter bar with price and style chips.
  • A horizontally scrolling carousel of recommended gowns.
  • A tappable comparison view with key attributes (fabric, length, shipping).
  • A follow-up form to refine preferences.

Crucially, the AI output is not arbitrary Swift code. It is a schema instance—essentially a high-level, typed description of the screen that the backend can inspect.

Server Validation and Orchestration

Uzori keeps the backend in control of what users see.

The server validates the AI-composed layout against:

  • Allowlisted components and properties.
  • Business rules (e.g., compliance for certain product categories).
  • Data access constraints (which APIs can be called and how results are shown).

Because this is a server-driven flow, you can instrument and observe it like any other backend system. You can roll out new assistant behaviors, tweak layouts, or apply A/B tests without shipping new binaries.

Streaming SwiftUI Screens in Real Time

The iOS SDK connects to Uzori’s engine as a single-screen integration.

When the user interacts with the assistant surface, the app receives a stream of validated layout updates—similar to how you’d stream chat tokens, but at the level of full SwiftUI screens and subviews.

The result is a conversational, dynamic UX:

  • The interface evolves as the user clarifies intent.
  • Wizards can insert or remove steps on the fly.
  • Product explorers can switch between lists, detail pages, and side-by-side comparisons without you hand-coding each transition.

This is server-driven UI tuned for AI-native workflows: the server owns the shape, AI proposes it, SwiftUI renders it.

Related Terms and How They Differ

Server-driven UI on iOS is often confused with a few adjacent concepts. For Uzori’s audience, these distinctions matter.

Server-Driven UI vs. Traditional Client-Side UI

In traditional client-side UI, screens and flows are baked into the app code.

Adding a new configuration wizard or product explorer means writing new SwiftUI views and shipping an update. The backend sends only data, not layout instructions.

In server-driven UI, the backend describes both data and layout. The app acts as a renderer of server-provided screen structures, which can change without a new binary.

Server-Driven UI vs. Pure Chat Interfaces

Pure chat UI surfaces bolt an LLM onto the app with a text box and a transcript.

The model answers with paragraphs, and the user manually translates those into actions: tapping around other screens, copying details into forms, or reconstructing comparisons.

Server-driven UI with Uzori instead turns the model’s understanding into directly operable UI: forms, lists, toggles, comparison tables, and multi-step flows that the user can tap through without reading long explanations.

Server-Driven UI vs. Unconstrained Generative UI

Some generative UI approaches let models emit arbitrary JSON or even executable code, which the client trusts and renders.

Uzori’s pattern is deliberately constrained and validated. The AI agent emits layouts inside a fixed schema, and the backend validates every screen before it reaches the user.

This aligns with industry insights from platforms like Thesys/OpenUI: production-ready generative UI needs validation, fallbacks, and governance. Server-driven UI provides that governance layer for iOS.

Example: AI Concierge for Roaming Protection in a SwiftUI App

Consider an iOS team building an AI concierge to help users configure roaming protection for upcoming trips.

In a traditional architecture, you might design:

  • A static multi-step form for trip details.
  • A few hard-coded plan comparison screens.
  • Separate flows for edge cases (dual-SIM, business accounts, regional restrictions).

Each change requires new SwiftUI code and careful maintenance.

With server-driven UI and Uzori:

  1. The user opens an "Roaming Assistant" surface built with the Uzori iOS SDK.
  2. They type, "I’m going to Italy for 10 days, mostly data, minimal calls. What plan should I use?"
  3. Uzori’s AI engine calls your backend APIs (plan catalog, usage history, eligibility rules) and composes a plan explorer layout:
    • A trip summary header.
    • A card stack of recommended plans.
    • A comparison view with estimated cost and coverage.
    • A toggle to include business-ready options.
  4. The server validates this layout against your schema and policy: e.g., no deprecated plans, correct pricing formats, and region-specific disclaimers.
  5. The validated SwiftUI schema is streamed into the app. The user sees native cards, lists, and toggles that match your existing design system, and can select a plan directly from that screen.

As the user asks follow-up questions—"What if I also visit Switzerland?" or "Show me only plans with hotspot included"—the AI engine updates the layout and the backend streams modified screens.

The result is a task-focused, AI-native experience: the user never leaves your app’s design language, and you never lose architectural control. Server-driven UI is the pattern that makes this possible.

For teams ready to experiment with this approach, Uzori’s platform at uzori.ai offers a SwiftUI-first implementation of server-driven, AI-composed interfaces for iOS apps.

← All posts