Patch Updates for React Native — Modern CodePush Alternative with 98% Smaller OTA Updates

The Problem With Full-Bundle OTA Updates

A small JavaScript fix shouldn't always mean sending an entire update artifact to every affected device.

With full-bundle OTA delivery, a tiny code change can still require users to download a much larger bundle. At scale, that means more bandwidth, longer downloads, and more data transferred for releases where only a small part of the application changed.

Microsoft's hosted App Center CodePush service used a traditional full-bundle OTA delivery model. Modern OTA systems, including Expo EAS Update, also support differential delivery in eligible scenarios. Even with differential delivery, teams can still receive full bundles when a suitable patch is unavailable, not yet generated, or not meaningfully smaller.

Stallion Patch Updates supports binary-safe differential delivery with automatic generation for sequential releases and on-demand patch generation between any two compatible Stallion versions. This gives teams more flexibility when multiple versions remain active in the field.

Meet Stallion Patch Updates

Stallion Patch Updates uses binary-safe, file-level differential patching to reduce the amount of data transferred between compatible releases.

Instead of treating every release as a completely new full-bundle download, Stallion analyzes compatible releases and generates a differential patch containing the data required to move from the source version to the target version.

In Stallion's verified benchmark scenario:

• Full bundle: 20 MB
• Patch: 400 KB
• Reduction: 98%

Actual patch sizes depend on what changed between releases. The 98% figure is a verified benchmark scenario, not a guarantee for every update.

Why Smaller OTA Updates Matter

Less data to download

A smaller patch means users transfer less data when receiving an update. This matters particularly for large user bases, frequent releases, and users on slower or metered connections.

Lower bandwidth consumption

If a release can be delivered as a 400 KB patch instead of a 20 MB full bundle, the difference compounds across users.

For example:

• 1,000 users × 20 MB = 20 GB
• 1,000 users × 400 KB ≈ 400 MB

The exact savings depend on the patch size and the number of users receiving it.

Faster downloads

Smaller artifacts generally take less time to transfer than larger full bundles, although actual download time depends on network conditions, device performance, and other factors.

More practical frequent releases

Reducing the amount of data required for small releases can make frequent OTA fixes and feature updates easier to deliver at scale.

File-Level Differential Updates

Stallion analyzes release contents at the file level and generates a binary-safe differential patch containing the data required for the target version.

This can avoid transferring unchanged content that is already available on the device. For example, if a release changes a single component while leaving most of the application unchanged, the resulting patch can be substantially smaller than the full bundle.

This is particularly useful for:

• small bug fixes
• UI changes
• configuration changes
• incremental feature releases
• frequent JavaScript updates

How Stallion Patch Updates Work

If Patch Updates are enabled for the project, the normal upload and release workflow remains the same.

1. Upload the bundle — Build the React Native bundle and upload it using the existing Stallion CLI workflow.
2. Promote the release — Promote the release through the Stallion Console or release workflow.
3. Generate the differential patch — Stallion compares the relevant releases and generates the patch when applicable.
4. Deliver the appropriate update — A compatible device can receive the smaller patch instead of downloading the entire target bundle when a patch is available.
5. Verify and apply — The patch is verified and applied as part of the OTA update process.

First Release vs Incremental Releases

The initial app bundle is different from subsequent OTA releases. The default bundle shipped with the native app build is already present on the device and is not itself a previously published OTA release available as a patch source.

For an app version:

• Initial/default bundle: included with the native app build
• First OTA release: may require the full OTA bundle
• Subsequent compatible releases: can use differential patches when Patch Updates are enabled and a patch is available

Example: 20 MB Bundle → 400 KB Patch

Consider a React Native application with a 20 MB full update artifact.

Full-bundle delivery

• 20 MB transferred per affected user
• Larger download
• Higher bandwidth consumption

Stallion Patch Update

In Stallion's verified benchmark scenario:

• 400 KB patch
• 98% less data
• Smaller artifact to transfer

For 1 million users receiving the same release:

• Full bundle: approximately 20 TB
• 400 KB patch: approximately 400 GB
• Difference: approximately 19.6 TB

This is an illustrative scale calculation based on the verified 20 MB → 400 KB benchmark. Actual traffic depends on the patch size, how many users receive the patch, and which users require a full bundle.

Stallion also supports on-demand patch generation between any two compatible Stallion versions. This means a device can move across a version gap without requiring every intermediate release to be the patch source. When the requested source-to-target patch does not yet exist, the initial request may receive the full target bundle while the differential patch is generated for subsequent matching requests.

Designed for Frequent OTA Releases

Patch Updates fits into the existing Stallion release workflow.

Existing release workflow

If the team already uses Stallion for OTA releases, Patch Updates is designed to work within that workflow rather than requiring a separate patching system.

Backward compatibility

Existing full-bundle releases continue to work. Patch delivery is used when the relevant patch is available.

Patch analytics

The React Native Stallion Console surfaces:

• patch size vs full bundle size
• patch efficiency
• users receiving patches vs full bundles

Why Teams Moving From CodePush Care

Microsoft's hosted App Center CodePush service is retired. CodePush forks and self-hosted implementations can vary in capabilities, so teams migrating today should evaluate the specific implementation they operate.

CodePush / App Center

• Microsoft's hosted App Center CodePush service is retired
• Existing forks and self-hosted implementations vary in capabilities
• Teams operating their own infrastructure own hosting, availability, maintenance, upgrades, and compatibility

Stallion

• Managed hosted OTA platform
• Binary-safe differential Patch Updates
• Automatic patches for sequential releases
• On-demand any-to-any patch generation
• File-level differential processing
• Release analytics
• Rollback and rollout controls
• Hosted, regional, self-hosted, and on-premise options where applicable

For teams where OTA download size, bandwidth consumption, frequent releases, and version flexibility are important, Stallion's differential patch model provides a more flexible delivery approach than a traditional full-bundle OTA workflow.

Patch Updates is available on Pro and Enterprise plans, and requires React Native Stallion SDK 2.4.0 or later.

Getting Started With Patch Updates

If you already use Stallion:

1. Open the project in the Stallion Console.
2. Go to Project Settings → Patch Settings.
3. Enable Patch Updates.
4. Continue using the normal upload and promote workflow.
5. Monitor patch generation and delivery in the Console.

Patch Updates is designed to fit into the existing OTA workflow without requiring a separate application-side patching system.

Ship Smaller OTA Updates

If your team ships frequent React Native OTA updates, reducing the amount of data required for each release can make a meaningful difference at scale.

See how Stallion Patch Updates works, review the SDK requirements, and enable it from your project settings.

Read the Patch Updates Documentation →

Get Started Free →

Already on CodePush? View the CodePush Migration Guide →

Frequently Asked Questions

What are Patch Updates?

Patch Updates are differential OTA updates that contain the changed content needed to move a compatible release from one version to another. Stallion uses binary-safe, file-level differential processing to reduce update size. In verified benchmark scenarios, updates can be up to 98% smaller than the corresponding full bundle.

How do Patch Updates compare to CodePush?

Microsoft's hosted App Center CodePush service is retired, while CodePush forks and self-hosted implementations can vary in capability. Stallion Patch Updates can deliver a substantially smaller differential patch when the relevant patch is available, with automatic sequential patches and on-demand generation between any two compatible versions.

Can I migrate from CodePush to Stallion?

Yes. Stallion provides a CodePush migration guide for React Native teams, covering the SDK and release workflow changes required for your project.

Are Patch Updates available for all React Native apps?

Patch Updates is available for projects using the supported React Native Stallion SDK version and an eligible Stallion plan. Current documentation lists SDK 2.4.0+ and Pro or Enterprise plans. Check the current documentation before implementation.

Can Stallion generate a patch between non-consecutive versions?

Yes. Stallion supports on-demand patch generation between any two compatible Stallion bundle versions. This allows teams to generate patches across version gaps when multiple releases remain active in production. If the requested source-to-target patch has not yet been generated, the first request may receive the full target bundle while the patch is generated for subsequent matching requests.

How much smaller are Patch Updates?

Patch Updates can be up to 98% smaller than a corresponding full bundle. In Stallion's verified benchmark scenario, a 20 MB update was reduced to a 400 KB patch. Actual patch size depends on what changed between releases.