---
title: "Expo Updates vs Shorebird vs CodePush: Mobile OTA Updates 2026"
author: "Nate Laquis"
author_role: "Founder & CEO"
date: "2030-01-27"
category: "Technology"
tags:
  - mobile OTA updates
  - Expo Updates
  - Shorebird
  - CodePush
  - React Native
excerpt: "OTA updates let you ship bug fixes and features to users in minutes instead of waiting days for App Store review. But the three major platforms handle it very differently. Here is how Expo Updates, Shorebird, and CodePush actually compare in 2026."
reading_time: "14 min read"
canonical_url: "https://kanopylabs.com/blog/expo-updates-vs-shorebird-vs-codepush"
---

# Expo Updates vs Shorebird vs CodePush: Mobile OTA Updates 2026

## Why OTA Updates Changed Mobile Development

The traditional mobile release cycle is brutal. You fix a critical bug, submit the binary to Apple, wait one to three days for review, and then hope your users actually update. Meanwhile the broken version keeps accumulating one-star reviews. Google Play is faster, but you are still looking at hours of processing time and a rollout that depends entirely on user behavior.

Over-the-air updates bypass that entire bottleneck for a specific class of changes. Instead of shipping a new binary through the store, you push updated JavaScript bundles (or in Shorebird's case, Dart code) directly to devices. The app pulls the update on launch, applies it, and your users are running the fixed version within minutes. No store review. No waiting for users to tap "Update" in the app store.

The constraint is important to understand upfront: OTA updates only work for code and assets that live above the native layer. If your fix involves a new native module, a change to your Android manifest, or an updated iOS entitlement, you still need a full binary release. But the vast majority of day-to-day development, bug fixes, UI tweaks, business logic changes, feature flags, and content updates, lives squarely in the OTA-eligible layer.

![Multiple mobile devices displaying app interfaces with code update notifications](https://images.unsplash.com/photo-1512941937669-90a1b58e7e9c?w=800&q=80)

Three platforms dominate this space in 2026: Expo Updates (formerly EAS Update), Shorebird, and CodePush. Each takes a fundamentally different approach to the same problem, and the right choice depends on your framework, your team size, and how aggressively you ship. We have deployed all three across client projects, and the differences are more significant than most comparison articles acknowledge.

## Expo Updates: The Integrated Default for React Native

If you are building with [Expo or bare React Native with EAS](/blog/expo-vs-bare-react-native), Expo Updates is the path of least resistance and, for most teams, the best option. It is deeply integrated into the Expo ecosystem. Configuration is minimal. The tooling is mature. And it handles the hard parts (binary compatibility checks, channel management, rollback) without requiring you to build custom infrastructure.

### How It Works

Expo Updates works by publishing JavaScript bundles and static assets to Expo's CDN. When your app launches, it checks for a new update on its assigned channel (production, staging, preview, or any custom channel you define). If an update is available and compatible with the running native binary, the app downloads it in the background. By default, the update applies on the next app launch, though you can configure it to apply immediately with a reload prompt.

The binary compatibility system is one of Expo Updates' strongest features. Every update is tagged with a **runtimeVersion** that maps to a specific native binary configuration. If you publish an update that references a native module your users' installed binary does not include, Expo Updates will not deliver that update to those devices. This prevents the class of crashes where an OTA update tries to call native code that does not exist, a problem that plagued early CodePush deployments.

### Pricing and Limits

Expo's free tier includes 1,000 monthly active users for updates. The Production plan at $99/month raises that to 50,000 monthly active updates. The Scale plan at $499/month handles 200,000. For apps beyond that threshold, custom enterprise pricing is available. The pricing model is based on monthly active updated users, not total app installs or total updates published, which makes it predictable for most teams.

One detail that matters at scale: Expo Updates uses a global CDN for distribution. Update download speeds are consistently fast regardless of user geography. We have measured sub-two-second update downloads for bundles under 5MB across North America, Europe, and Southeast Asia. Larger bundles with significant asset changes take proportionally longer, but the CDN performance is solid.

### Staged Rollouts and Channels

Expo Updates supports channel-based distribution, which gives you staged rollout capability. You can publish an update to a "canary" channel that targets a small percentage of users, monitor crash rates and analytics, and then promote it to production. The channel system also supports branching, so your staging environment can run a completely different update branch than production. This is table-stakes functionality, but Expo implements it cleanly and it integrates directly with the EAS CLI.

## Shorebird: OTA for Flutter, Now Expanding to React Native

Shorebird started as a Flutter-first OTA platform and quickly became the default choice for Flutter teams that needed over-the-air updates. Its core innovation is Dart-level patching: instead of replacing the entire application bundle, Shorebird generates a binary diff at the Dart VM level and patches only the changed code. This makes updates extremely small, often under 100KB even for significant feature changes.

### The Technical Approach

Shorebird's patching engine works by comparing compiled Dart code between the release version and the update. It generates a minimal patch file that the Shorebird runtime on the device applies to the existing compiled code. This is fundamentally different from Expo Updates, which replaces the entire JavaScript bundle. The result is faster downloads, lower bandwidth consumption, and faster apply times on device.

For Flutter apps, this is genuinely impressive. A typical Shorebird patch is 50 to 200KB compared to a full Flutter release artifact that can be 15 to 30MB. The update downloads in under a second on most connections and applies instantly. Users never see a loading screen or update prompt unless you explicitly build one.

Shorebird has also begun supporting React Native, though the integration is newer and less battle-tested than Expo Updates. For React Native projects, Shorebird operates more similarly to CodePush, replacing the JavaScript bundle rather than doing Dart-level patching. This means the size advantage narrows considerably when comparing Shorebird on React Native to Expo Updates. The primary reason to consider Shorebird for React Native in 2026 is if you also maintain Flutter apps and want a single OTA platform across both.

![Developer laptop showing code editor with mobile app OTA update deployment scripts](https://images.unsplash.com/photo-1517694712202-14dd9538aa97?w=800&q=80)

### Pricing

Shorebird's Hobby tier is free for up to 5,000 patch installs per month. The Team plan is $20/month per app with 50,000 patch installs. The Business plan at $100/month per app covers 250,000 patch installs and adds priority support. Enterprise pricing is negotiated individually. Compared to Expo Updates, Shorebird is meaningfully cheaper at similar scale for Flutter apps, though the comparison is apples-to-oranges since Expo's pricing bundles other EAS services.

### Rollback and Binary Compatibility

Shorebird supports instant rollback by reverting to the previous patch or the original release binary. Binary compatibility is handled through release tracking: each patch is tied to a specific release version, and Shorebird will only deliver patches that match the installed binary. The system is less sophisticated than Expo's runtimeVersion approach, but it works reliably in practice. You need to be disciplined about tracking which release versions are in the wild, especially if you have a long tail of users on older versions.

## CodePush: The Legacy Option and Its Community Future

CodePush has a complicated history. Microsoft built it as part of the App Center platform, and for several years it was the dominant OTA solution for React Native. Then Microsoft announced App Center's deprecation, and CodePush entered a slow sunset. As of 2026, the original Microsoft-hosted CodePush service is officially end-of-life.

But CodePush did not die. The community forked the project, and several maintained versions exist. The most active is the **react-native-code-push** community fork, which operates as a self-hosted or third-party-hosted solution. There are also commercial services that offer CodePush-compatible backends, effectively replacing Microsoft's infrastructure with independently operated servers.

### How CodePush Works

CodePush replaces the JavaScript bundle and assets on the device, similar to Expo Updates. It supports mandatory and optional updates, immediate or deferred installation, and rollback based on crash detection. The client SDK checks for updates at configurable intervals or on specific app lifecycle events, downloads the new bundle, and applies it either immediately or on the next restart.

The update mechanism is straightforward but lacks some of the sophistication of newer platforms. Binary compatibility checking is manual: you specify a target binary version when publishing an update, and CodePush only delivers it to devices running that version. There is no automatic runtimeVersion inference like Expo Updates provides. If you misconfigure the target version, you can push an incompatible update that crashes the app. This happened frequently enough in practice that most experienced CodePush users built additional validation layers around their deployment scripts.

### Why Teams Still Use It

Despite its legacy status, CodePush remains in production at a surprising number of organizations. The reasons are practical rather than technical. Teams that built their release pipelines around CodePush years ago have working systems they do not want to migrate. The community-maintained versions are stable enough for existing deployments. And for teams running [React Native outside the Expo ecosystem](/blog/react-native-vs-flutter), CodePush was historically the only viable option.

That said, we do not recommend CodePush for new projects in 2026. The community maintenance is competent but understaffed relative to the surface area of the codebase. Security patches lag behind. The documentation is fragmented across multiple forks. And the feature set has stagnated while Expo Updates and Shorebird have continued to evolve. If you are starting fresh, either of the other two options is a better foundation.

### Self-Hosting Considerations

One advantage CodePush still holds is self-hosting capability. If your organization requires that update infrastructure runs on your own servers, perhaps for regulatory, compliance, or data sovereignty reasons, the open-source CodePush server can be deployed on-premises. Neither Expo Updates nor Shorebird offers a self-hosted option in their standard tiers, though Expo does offer custom deployments for enterprise customers. For regulated industries like healthcare or finance where update infrastructure must live within a controlled environment, self-hosted CodePush may still be the pragmatic choice despite its other drawbacks.

## Head-to-Head Comparison: The Details That Matter

Abstract comparisons only get you so far. Here are the concrete differences across the dimensions that actually affect your team's workflow and your users' experience.

### Update Size and Speed

Shorebird wins on update size for Flutter apps, often delivering patches under 100KB. For React Native, the difference between Shorebird and Expo Updates is marginal since both are replacing JavaScript bundles. Expo Updates bundles are typically 1 to 8MB depending on your app's complexity and included assets. CodePush bundles are comparable in size to Expo Updates. All three platforms use CDNs or edge distribution, so download speeds are fast on reasonable connections. The practical impact of update size differences is minimal for most apps unless you are targeting users on extremely constrained networks.

### Rollback Capabilities

Expo Updates offers the most robust rollback system. You can roll back to any previously published update on a channel, and the rollback propagates immediately through the CDN. Shorebird supports rollback to the previous patch or original release. CodePush supports automatic rollback triggered by crash detection within a configurable window after update installation, which is a useful safety net but less flexible than manual rollback controls.

### Staged Rollouts

Expo Updates handles staged rollouts through channels and percentage-based targeting. You can roll an update out to 5% of users, then 25%, then 100%, monitoring metrics at each stage. Shorebird supports percentage-based rollouts on its Team plan and above. CodePush's community version supports staged rollouts, but the implementation varies across forks and the reliability depends on which backend you are using.

### Binary Compatibility

This is where Expo Updates has a clear structural advantage. The runtimeVersion system automatically prevents incompatible updates from reaching devices. You define your runtimeVersion policy (typically tied to your native build configuration), and Expo Updates enforces compatibility without manual intervention. Shorebird ties patches to release versions, which works but requires careful version management. CodePush relies on manual target version specification, which is error-prone at scale.

### Pricing Comparison at 100K Monthly Active Users

At 100,000 monthly active users receiving updates, Expo Updates costs approximately $499/month (Scale plan). Shorebird costs approximately $100/month per app (Business plan), though you will likely need multiple apps if you maintain both iOS and Android. CodePush community versions are free to self-host but carry the infrastructure and maintenance costs of running your own update servers, which typically runs $50 to $200/month in cloud hosting depending on your traffic patterns.

![Modern software development office with team collaborating on mobile app deployment strategy](https://images.unsplash.com/photo-1504384308090-c894fdcc538d?w=800&q=80)

## Choosing the Right Platform for Your Stack

The decision tree is simpler than it appears. Your framework choice eliminates options immediately, and from there it is a matter of scale, budget, and operational preferences.

### If You Are Building with Expo or React Native

Use Expo Updates. The integration depth, binary compatibility checking, and channel management system make it the strongest option for the React Native ecosystem. The pricing is reasonable for most app scales, and the tooling is mature. You get OTA updates as part of the broader EAS platform, which also handles builds, submissions, and environment configuration. The unified toolchain reduces operational overhead compared to stitching together separate services for each concern.

The only scenario where a React Native team should look elsewhere is if you specifically need self-hosted update infrastructure for compliance reasons. In that case, evaluate self-hosted CodePush or Expo's enterprise custom deployment option.

### If You Are Building with Flutter

Use Shorebird. It is purpose-built for Flutter, the Dart-level patching produces dramatically smaller updates than any JavaScript-based approach, and the pricing is competitive. The Flutter ecosystem does not have an equivalent to Expo's integrated platform, so Shorebird fills a critical gap. The team behind Shorebird is responsive and the product is actively evolving with Flutter's release cadence.

### If You Maintain Both React Native and Flutter Apps

This is the one scenario where the decision gets genuinely difficult. You can use Expo Updates for your React Native apps and Shorebird for Flutter, which gives you the best tool for each platform but means managing two OTA systems with different dashboards, CLI tools, and mental models. Alternatively, you can use Shorebird for both, accepting that its React Native support is less mature than Expo Updates in exchange for a single platform. We have seen teams go both ways. Our recommendation is to use the best tool per platform unless your team is small enough that the cognitive overhead of two systems is a real burden.

### If You Have Legacy CodePush Infrastructure

If CodePush is working for you today, there is no urgent reason to migrate. But plan for it. The community maintenance model is not sustainable long-term for a critical piece of infrastructure. When you do migrate, Expo Updates is the natural destination for React Native projects. Budget the migration as a one to two sprint effort for a mid-sized app, primarily around updating your CI/CD pipeline and testing the update flow across your device matrix. For a detailed look at how the broader Expo ecosystem handles this, check out our [Expo SDK migration guide](/blog/expo-sdk-55-migration-guide).

## Implementation Best Practices and Our Recommendation

Regardless of which platform you choose, the operational patterns around OTA updates matter as much as the technology. Here are the practices we follow across every client project that uses OTA updates.

### Always Gate Critical Updates

Use staged rollouts for every update that touches core business logic. Roll to 5% first, monitor crash rates and key metrics for at least an hour, then expand. The temptation to push a "small fix" straight to 100% is strong, and it will eventually burn you. Treat every OTA update with the same rigor you would apply to a database migration: test it, stage it, monitor it, then promote it.

### Set Up Automatic Rollback Triggers

Configure your monitoring stack (Sentry, Datadog, or similar) to trigger an automatic rollback if crash rates spike within 15 minutes of an update deployment. Both Expo Updates and Shorebird support programmatic rollback through their CLIs, which means you can integrate rollback into your alerting pipeline. CodePush has built-in crash-based rollback, but supplementing it with external monitoring gives you faster response times.

### Separate Your Update Channels from Your Build Channels

Run at least three channels: development (for internal testing), staging (for QA and beta testers), and production. If your app has a significant user base, add a canary channel between staging and production. Each channel should map to a specific runtimeVersion or release version so that binary compatibility is enforced automatically. This is trivial to set up in Expo Updates, straightforward in Shorebird, and requires manual discipline in CodePush.

### Monitor Update Adoption Rates

Track what percentage of your active users are running the latest OTA update. If adoption is low, investigate whether updates are failing to download (network issues, oversized bundles) or failing to apply (compatibility mismatches, interrupted app sessions). Both Expo Updates and Shorebird provide adoption metrics in their dashboards. Low adoption rates often indicate a configuration problem rather than user behavior.

### Our Bottom Line

OTA updates are not optional for teams that ship mobile apps on a weekly or biweekly cadence. The ability to push a fix in ten minutes instead of waiting two days for App Store review is a competitive advantage that compounds over time. For React Native teams, Expo Updates is the clear winner in 2026. For Flutter teams, Shorebird is the right choice. CodePush served the community well for years, but its time as a recommended solution has passed.

If you are building a mobile app and want help setting up a release pipeline with OTA updates baked in from day one, that is exactly the kind of architecture work we do with clients. [Book a free strategy call](/get-started) and we will walk through the right setup for your specific app and team.

---

*Originally published on [Kanopy Labs](https://kanopylabs.com/blog/expo-updates-vs-shorebird-vs-codepush)*