Pyramid vs Expo Updates: Which One Do You Actually Need?

If you're building a React Native app with Expo, you've probably heard about Expo Updates. It lets you push JavaScript changes to your app without going through the App Store. Pretty convenient, right?

But then you hear about server-driven UI (SDUI) and wonder: is that the same thing? Do I need both? Which one solves my actual problem?

Here's the honest breakdown.

---

The Core Difference

Expo Updates pushes new code to your app. The UI is still defined in your JavaScript bundle — you're just updating that bundle more frequently.

Pyramid (SDUI) pushes new UI layouts from your server. The UI isn't in your code at all — it's defined on your backend and rendered by the app at runtime.

When Expo Updates Is Enough

Expo Updates works great when you need to:

• Fix JavaScript bugs without waiting for App Store review
• Update copy or translations stored in your code
• Tweak styling or layout defined in your stylesheets
• Roll out small feature changes that are already coded but feature-flagged

If your updates are mostly bug fixes and minor tweaks, Expo Updates might be all you need. It's already built into Expo, so there's nothing extra to set up.

Limitations of Expo Updates

• Code has to exist first. You can't push UI that isn't in your bundle. Want a new onboarding flow? You have to code it, build it, get it approved once, then toggle it on.
• Bundle size matters. Every feature you might use goes in the bundle, even if it's turned off. Your app gets bloated with dormant code.
• Testing is still manual. You can push updates, but you're pushing code. Breaking changes can still break your app.
• No server-side control over layout. The server sends data; the client decides how to render it. Want to A/B test two completely different layouts? You need both layouts in your code.

When You Need Pyramid (SDUI)

Pyramid makes sense when you need to:

• Ship new UI without any client release. Your backend serves the layout, and the app renders it. Zero App Store delays.
• Run real A/B tests on layouts. Not just "show button A or B" — but "show completely different screen structures." The server decides which layout to send.
• Let non-engineers make UI changes. Marketing wants to change the promo banner? Product wants to tweak onboarding? With SDUI, they don't need a developer to push code.
• Keep your app lightweight. The app only has the rendering engine. All the "what to display" lives on the server. Your bundle stays small.
• Instantly roll back UI. Push a bad layout? Change the server response. Every user sees the fix immediately.

Real-World SDUI Use Cases

Promotional campaigns. Black Friday sale? New product launch? Change the home screen instantly.

dynamic onboarding flows. Test 5 different onboarding sequences without coding all 5 into your app.

Dynamic feature sections. Show different features to different user segments, controlled from your backend.

Rapid iteration. Ship a new screen, see analytics, tweak it, ship again — all in the same day.

Comparing the Two

Feature	Expo Updates	Pyramid (SDUI)
What it updates	JavaScript code	UI layout from server
App Store required?	No (after initial)	No
Update speed	Minutes to hours	Instant
New UI without release	Only if code exists	✅ Yes
A/B testing layouts	Limited	✅ Full server control
Bundle size	Grows with features	Stays small
Non-dev UI changes	❌ No	✅ Yes

Can You Use Both?

Yes, and many teams do.

Here's a common setup:

1. Use Expo Updates for bug fixes and small code changes
2. Use Pyramid for screens that change frequently (home, promotions, onboarding)

Your "static" screens (settings, profile, etc.) stay as regular React Native code. Your "dynamic" screens (anything marketing touches) use server-driven UI.

This hybrid approach gives you:

• The familiarity of React Native development
• The flexibility of instant UI updates where you need them
• No need to rewrite your entire app

Integration Example

Here's how a hybrid approach might look in your code:

// Regular React Native screen (updated via Expo Updates)
function SettingsScreen() {
  return (
    <View>
      <Text>Settings</Text>
      {/* ... normal React Native code */}
    </View>
  );
}

// Pyramid-powered screen (updated via server)
function HomeScreen() {
  return (
    <PyramidScreen 
      route="/home" 
      fallback={<HomeSkeleton />}
    />
  );
}

The PyramidScreen component fetches its layout from your backend. Change the backend response, and the UI changes. No code push needed.

The Decision Framework

Choose Expo Updates if:

• You're mostly fixing bugs and making small tweaks
• You have a small team and want minimal new infrastructure
• Your UI doesn't change that frequently
• You're already using Expo and happy with the workflow

Add Pyramid if:

• You're tired of waiting for App Store approvals for UI changes
• Marketing/product wants to change UI without engineering sprints
• You want to A/B test screen layouts, not just features
• You're shipping UI updates weekly or more frequently
• You want to keep your app bundle small as you add features

Use both if:

• You have a mix of stable screens and frequently-changing screens
• You want the safety net of Expo Updates for code fixes
• You're migrating gradually and don't want to rewrite everything

What About Compliance?

Both approaches are App Store compliant when used correctly:

Expo Updates follows Apple's guidelines for interpreted code as long as you're not fundamentally changing the app's purpose.

Pyramid (SDUI) doesn't push code at all — it's server content, like how news apps load articles. Apple explicitly allows this pattern.

The key is that your app's core functionality is already approved. You're just changing what content (including UI layouts) the app displays.

Getting Started with Pyramid

If you're intrigued by server-driven UI but want to test it without rewriting your app:

1. Identify one screen that changes frequently (home, promotions, onboarding)
2. Try the DSL playground to see how layouts are defined
3. Integrate the SDK into just that one screen
4. Keep using Expo Updates for everything else

You don't have to go all-in. Start with one screen, see the benefits, expand from there.

FAQ

Is Pyramid a replacement for Expo?

No. Pyramid is a tool that works alongside your existing React Native setup, including Expo. You keep using Expo for development, builds, and Expo Updates. Pyramid handles the screens where you need instant server control.

Does Pyramid work with bare React Native (no Expo)?

Yes. Pyramid's SDK works with both Expo and bare React Native projects.

How much effort is integration?

For a single screen: a few hours. The SDK is lightweight, and you can start with one screen to test the workflow before expanding.

What happens if the server is down?

You configure fallback UI. The app renders a cached or default layout if the server is unreachable. Your app doesn't break.

---

Last updated: March 2026