Server-driven UI migration: incrementally adding AI-shaped screens to an iOS app
The safest way to introduce server-driven, AI-shaped UI into an iOS app is to add a few high-leverage SwiftUI screens incrementally, not rewrite your…

Server-driven UI migration: incrementally adding AI-shaped screens to an iOS app
The safest way to introduce server-driven, AI-shaped UI into an iOS app is to add a few high-leverage SwiftUI screens incrementally, not rewrite your architecture. Start with bounded flows like billing questions or plan comparisons, wrap them behind a server UI layer, and use feature flags to control rollout. Tools like the Uzori SDK for SwiftUI make this a one-screen integration while keeping everything native and safe.
This guide lays out a phased approach for incremental server-driven UI migration on iOS, using Uzori as the concrete example for streaming SwiftUI screens from your backend and AI engine.
Why incremental server-driven UI migration beats a big-bang rewrite
Before diving into phases, it’s important to frame why incremental migration is the right path for server-driven and AI UI.
Server-driven UI is powerful—but best used surgically
Thoughtworks moved server-driven UI (SDUI) back to their Trial ring in April 2026, explicitly recommending it for:
- Highly dynamic surfaces with frequent layout changes
- Experiment-heavy areas where app-store cadence is a bottleneck
- Flows that benefit from centralized control and rapid iteration
They also warn against turning SDUI into a "god-protocol" that owns everything.
The takeaway: use SDUI to modernize specific flows, not your entire app.
SwiftUI and incremental adoption: Apple’s own playbook
Apple’s SwiftUI guidance is clear: you can layer SwiftUI into existing apps incrementally.
- SwiftUI works alongside UIKit via hosting controllers
- WWDC26 sessions highlight adding complete SwiftUI scenes without changing the underlying architecture
- You don’t need to refactor navigation or state management just to add one new SwiftUI screen
This incremental mindset maps perfectly to AI-shaped, server-driven screens: one new scene at a time.
Market trend: AI UI is becoming structured, not just chat
Generative UI frameworks like Thesys’s OpenUI/GenUI, Voqal, and Shopify’s MCP UI all converge on the same idea:
- AI should respond with interactive components, not only text
- UI descriptions must be structured, constrained, and validated
- Streaming partial updates is critical for responsive AI experiences
Uzori applies that same pattern natively to SwiftUI: from AI answer to structured server UI to validated SwiftUI screens.
Phase 0: Choose the right surface for server-driven AI UI
The first step in any incremental server-driven UI migration on iOS is picking the right surface.
Target bounded, high-change flows
You want flows that:
- Change often (pricing, eligibility, plan details)
- Need experimentation (A/B tests, layout tweaks)
- Are currently too wordy or complex in chat form
Common candidates in product-led iOS apps:
- Billing questions: “Which roaming plan should I pick?”
- Plan comparisons: side-by-side views of tiers, limits, and upsells
- Onboarding wizards: multi-step, personalized configuration flows
- Product discovery: recommendation carousels, filters, and detail views
Shopify’s Shop app is a strong proof point here.
- They used SDUI on the Store screen to customize layouts per merchant
- Motivation: their weekly release cadence was too slow for experiments
- Result: faster iteration on millions of merchant storefronts for hundreds of millions of customers
Your equivalent is the billing/plan surface where you want AI to act as a concierge, not just a chatbot.
Define success and failure upfront
For each candidate flow, define:
- Primary metrics: conversion, task completion, time-to-decision
- Guardrails: latency, crash-free rate, layout correctness
- Fallback behavior: what users see if the server-driven UI fails
This makes it straightforward to justify expanding server-driven UI from one flow to many.
Phase 1: Wrap a single SwiftUI screen behind a server UI layer
Once you’ve picked a high-leverage flow, the next step is to wrap a single SwiftUI screen behind a server-driven UI schema.
From local SwiftUI to server-driven SwiftUI
Classic server-driven UI iOS frameworks like DivKit show that you can:
- Describe layouts on the server using structured JSON
- Render them natively on iOS with reusable components
- Embed server-driven views at the view level, not just full screens
Uzori builds on this idea, but with AI-shaped screens:
- Your backend exposes APIs (often via OpenAPI)
- Uzori’s engine uses an LLM plus your API spec to design a SwiftUI screen
- The screen is validated server-side against a constrained schema
- The app renders the result as native SwiftUI, not a web view
Uzori SDK SwiftUI integration: "one screen" pattern
A typical integration looks like:
- Add the Uzori iOS SDK (SwiftUI) to your app
- Create a single SwiftUI view that hosts the Uzori-generated content
- Wire the view into navigation for the chosen flow, e.g.:
BillingConciergeViewPlanComparisonAssistantView
- Pass initial context (user ID, current plan, region) to the Uzori engine
- Render the streamed SwiftUI screens inside your host view
The rest of your app remains unchanged:
- Navigation stays in your existing Router/Coordinator
- State management (e.g.,
ObservableObject,Store) is the same - Only the target screen is server-driven and AI-shaped
Feature flag the new server UI
To keep the migration non-disruptive, use feature flags.
LaunchDarkly’s migration guidance recommends:
- Pilot flags for a small audience or internal testers
- Fallback conditions for unexpected errors
- Gradual rollout and kill switches
You can implement the same with:
- A single
useServerDrivenBillingflag - Branching logic at the navigation decision point
- Instant rollback to the legacy SwiftUI view if needed
This is where AI UI solutions stay non-disruptive: the flag guards the new flow, and your existing billing screens remain intact.
Phase 2: Connect AI intent to native SwiftUI screens safely
With one server-driven SwiftUI host in place, you can start turning AI answers into native UI without breaking existing flows.
Generate native iOS UI from LLM responses
At a high level, the Uzori flow is:
- User asks a question, e.g. “Which roaming protection should I get for Italy?”
- The Uzori engine:
- Interprets the query
- Calls your backend APIs (described via OpenAPI)
- Chooses the right widgets: comparison cards, detail panels, forms
- It returns a screen description following a constrained SwiftUI schema
- Your server validates the description against business rules
- The app renders a native SwiftUI screen that:
- Shows recommended plans
- Highlights key differences
- Offers actions: upgrade, chat, learn more
This is where AI as interface, not just text becomes real.
Server-driven safety: schema, validation, fallback
Industry examples (Thesys, Voqal, DivKit) highlight three mandatory safety mechanisms:
- Structured schema: the UI is described in a typed contract
- Validation: malformed or disallowed layouts are rejected
- Fallbacks: the client can gracefully recover to known-good UI
Uzori follows the same pattern:
- SwiftUI screens are composed from a constrained, server-approved schema
- The server validates every screen before it’s streamed into the app
- If validation fails or times out, your client shows:
- A trimmed-down legacy billing view
- Or a known fallback card layout
This approach keeps AI UI tools safe for large-scale deployment while still allowing generative flexibility.
Don’t break existing flows
Because the server-driven screen is just one SwiftUI view in your navigation stack, you avoid:
- Rewrite of your routing or deep-linking
- Changes to your state store or data layer
- Forced adoption across unrelated product teams
The migration is opt-in per flow, controlled via flags and versioning.
Phase 3: Expand to more dynamic surfaces and multi-step flows
Once the first flow stabilizes, you can extend server-driven UI to other parts of your app.
Add more AI-shaped SwiftUI screens
Candidates for the second and third waves often include:
- Upsell surfaces: offer context-aware upgrades based on usage
- Configuration wizards: multi-step setup guided by AI
- Support concierges: AI screens that walk users through troubleshooting
- Product explorers: image grids, filters, and detail views for catalog items
Each new flow can follow the same pattern:
- Define a host SwiftUI view
- Wire it behind a feature flag
- Let Uzori stream task-specific SwiftUI screens based on user intent
Orchestrate multi-step AI flows
Generative UI platforms like Thesys talk about Layered UI Generation:
- Streaming partial layouts
- Handling events and callbacks
- Maintaining state across steps
Uzori applies that to SwiftUI by:
- Streaming updates as the user refines their request
- Moving from overview -> comparison -> detail -> checkout
- Keeping each step as a native SwiftUI screen under the same schema
You get rich task flows that compress weeks of UI iteration into AI-driven streams, but still:
- Look and feel like your app
- Use your design system
- Respect your existing backend contracts
Phase 4: Operationalization, experimentation, and governance
As you add more server-driven screens, the challenge shifts from integration to operations and governance.
Treat server-driven UI as shared infrastructure
Industry guidance from Thoughtworks, Voqal, and DivKit suggests:
- Keep the protocol minimal and disciplined
- Expose reusable widgets, not arbitrary ad-hoc layouts
- Version your schema to avoid breaking older clients
For an iOS AI UI layer, that means:
- Shared widget library: cards, lists, forms, steppers, tabbed panels
- Central documentation: schema, allowed components, best practices
- CI checks: schema validation and snapshot tests for critical flows
Experiment faster without app-store friction
Server-driven UI is particularly useful where release cadence is limiting.
Shopify’s Store screen SDUI rollout was driven by:
- Weekly client releases that slowed experimentation
- Need to customize layouts per merchant quickly
In your iOS app, Uzori-powered screens let you:
- Adjust layouts or copy server-side without app updates
- Test different comparison views for plans or pricing
- Roll back experiments by reverting server configs
This is where server-driven UI iOS frameworks prove their value: your experimentation loop moves from weeks to days.
How Uzori fits into an incremental server-driven UI migration
Bringing the phases together, Uzori acts as the AI interface layer for your SwiftUI app.
Summary of the phased rollout with Uzori
- Pick a high-leverage flow
- Billing concierge, plan comparisons, product discovery
- Add a single Uzori host screen
- Integrate the Uzori SDK into a SwiftUI view
- Wire it via feature flags
- Connect backend APIs and schema
- Describe your APIs via OpenAPI
- Adopt Uzori’s constrained SwiftUI schema
- Let AI compose, server validate, app render
- AI decides layouts and widgets
- Your server validates each screen
- Your app shows native SwiftUI views
- Expand, experiment, and govern
- Add more flows
- Run experiments without app updates
- Maintain a disciplined SDUI contract
For a deeper architectural walkthrough of server-driven UI on iOS with AI-shaped SwiftUI, see this guide: Server-driven UI on iOS: turn AI answers into native SwiftUI in real time.
You can explore the SDK and engine capabilities directly at uzori.ai.
FAQ: incremental server-driven UI migration on iOS
What is server-driven UI in iOS, and why use it for AI?
Server-driven UI (SDUI) means the server sends a structured description of the UI, which the client renders using local components.
For AI use cases, SDUI lets you:
- Turn AI answers into operable screens, not just text
- Centralize validation and business rules on the server
- Experiment on dynamic flows without app-store delays
Do I need to rewrite my iOS app to use AI-shaped server-driven screens?
No.
Apple explicitly supports incremental SwiftUI adoption, and SDUI can be embedded at the level of individual views.
With Uzori, you typically:
- Add one SwiftUI screen hosting the Uzori engine
- Gate it behind a feature flag
- Leave the rest of your app architecture unchanged
How do I keep server-driven AI UI safe and stable?
Safety comes from constraints and validation, not from the AI model alone.
Best practices include:
- Typed, versioned schema for screens and widgets
- Server-side validation of any AI-generated UI
- Fallback paths to legacy screens when validation fails
Uzori’s approach is: AI composes, your server validates, SwiftUI renders.
Which flows are best to start with for incremental migration?
Look for:
- Bounded flows with clear start/end
- High-change surfaces where copy or layout shifts often
- Areas where users currently face text-heavy, complex decisions
Examples:
- Billing and roaming protection selection
- Plan and tier comparisons
- Upsell and configuration wizards
How does server-driven AI UI affect performance and latency?
Performance depends on:
- Network latency to your SDUI/AI backend
- Efficiency of your schema and renderer
Vendor claims like Thesys’s 3x faster renders and 67% fewer tokens show that structured UI contracts can be efficient.
Uzori minimizes overhead by:
- Streaming UI updates instead of waiting for full responses
- Using native SwiftUI rendering on the client
- Validating screens server-side before they reach the device