How server-driven UI is revolutionizing mobile app experiences

At Careem, agility and adaptability are key to delivering highly personalized and seamless user experiences as we need to move fast to react to customer behaviour during different times of the year, such as Ramadan. With AppEngine, our Server-Driven UI (SDUI) framework, we have transformed how we build, deploy, and scale new app experiences—reducing engineering overhead while empowering business teams to execute faster.

Let’s dive into a problem to understand how we do this at Careem.

The problem: Slow, rigid experience updates

Ramadan is a critical period for the Careem Food business. Customers’ preferences change—people look for iftar deals, special bundles, and late-night suhoor options. Pre-AppEngine, adapting the app to reflect these changes was slow and engineering-intensive, requiring:

• Weeks of planning across Marketing, Product, Product Ops, and Engineering.
• Code-level changes to redesign discovery screens, promotions, and banners.
• App releases tied to release cycles, delaying execution and limiting agility.

This traditional approach restricted our ability to respond quickly to real-time trends. By the time updates went live, customer behavior could have already shifted.

The solution: Instant UI changes without app releases

With AppEngine, this entire process is now dynamic and configurable—without requiring app updates.

👉 Marketing & Product Ops can now adapt experiences on the fly through an authoring tool, without involving engineering or waiting for release cycles.

How does AppEngine allow for instant UI changes?

Instead of hardcoding UI elements in the app, AppEngine dynamically delivers UI layouts from the backend. This means:

• Marketing & Product Ops can configure personalized Ramadan themes, promotions, and curated food selections in real-time.
• Dynamic layouts adjust instantly based on user behavior (e.g., showing Iftar deals in the evening and Suhoor options late at night).
• Experimentation is easy—A/B testing new layouts and promotions can happen without deploying code changes.

The three pillars of AppEngine

AppEngine’s architecture is built around three core components, making this flexibility possible:

1. Mobile app: A thin, adaptive client

• The mobile app acts as a lightweight renderer, fetching UI configurations from the backend.
• It doesn’t contain business logic, making it easier to maintain and keeping it highly responsive.
• Once UI elements are introduced through an app release, any subsequent changes to their layout, content, or behavior can be managed dynamically from the backend—eliminating the need for additional app releases and enabling real-time adaptability.

2. Backend: The orchestrator of the experience

• The backend dynamically generates UI components, deciding what users see based on personalization, business rules and configs.
• It enables A/B testing, experimentation, and rapid iterations without app-side changes.
• Failover mechanisms ensure graceful degradation, so failures in one part of the experience don’t break the app.

3. Authoring: Business-controlled customization

• Product Ops can create and modify UI configurations through a self-serve authoring tool.
• No engineering intervention is needed—campaigns, promotions, and experiences can be launched in hours instead of weeks.
• Business logic can be defined using rules, triggers, and AI-powered recommendations.

The impact: Faster, smarter, more scalable

By moving to Server-Driven UI, we have unlocked massive benefits:

✅ Instant Updates – Ramadan-specific discovery screens, and sub-pages go live in hours, not weeks.
✅ AI-Driven Personalization – Users see curated iftar/sahoor deals based on time and behavior.
✅ Zero Engineering Overhead – Engineering can focus on building new capabilities rather than hardcoding UI changes.
✅ Dynamic Experimentation – A/B testing and promotions are now effortless.