CodePushGo

Production recovery for React Native

Ship React Native fixes without waiting for app review.

When a JavaScript bundle breaks production, CodePushGo gives your team a fast recovery path: publish a compatible update, watch adoption, and roll back before a bad release spreads.

Start live updates See pricing
Minutes
ship urgent JavaScript fixes
Channels
move updates through dev, beta, and production
Rollback
recover when a bundle behaves badly
Telemetry
see installs, failures, and active versions

release/production

Bundle v2.8.4

Payment fix promoted to Production

Live
Downloaded 86%
Ready after restart 71%

Channels

Production v2.8.4
Beta v2.9.0
Dev v3.0.0

Rollback guard

Healthy rollout

No failure spike detected. Keep monitoring before expanding the channel.

Learn how rollback works 
npm run build
npx @capgo/cli@latest bundle upload --channel=Production

Production proof

Trusted by teams that need JavaScript recovery paths in production.

Kick logo
Pizza Hut logo
RemNote logo
Revel logo
XBE logo
IREC logo
Suez logo
Vella logo
Ourliving logo

Release problem

A JavaScript bug should not turn into a multi-day app-store release.

CodePushGo keeps the scope narrow and useful: ship compatible JavaScript changes to users, observe the rollout, and recover quickly when a bundle misbehaves.

Store review slows hotfixes

A small JavaScript bug can sit behind app review, phased release settings, and user update behavior.

Rollbacks are too heavy

Without a live update layer, a bad JavaScript release often means preparing another binary just to undo it.

Teams ship blind

Version drift, partial installs, and failed downloads need release telemetry instead of guesses from support tickets.

Live update platform

Everything points to one outcome: safer JavaScript releases.

A focused release layer for bundle delivery, staged rollout, telemetry, rollback, and React Native operations without expanding into unrelated tooling.

Live JavaScript bundles

Send JavaScript and asset updates to installed React Native apps after the binary is already in production.

Channel promotion

Move a bundle from development to beta to production without rebuilding the native app each time.

Staged rollout control

Start small, watch adoption, and expand the channel only when the update behaves correctly.

Fast rollback path

Point a channel back to a known-good bundle when the newest release is not ready for all users.

Update telemetry

Track downloads, installs, failures, and active bundle versions while a release is rolling out.

CLI-first workflow

Run the same upload command locally or from GitHub Actions, GitLab CI, Jenkins, or your own pipeline.

Version guardrails

Keep native app versions on their normal store path and target live updates only where they are compatible.

Open source core

Use a transparent update pipeline you can inspect, reason about, and connect to the rest of your release process.

Workflow

A release path developers already understand.

Keep your React Native build process. CodePushGo adds the upload, channel, telemetry, and rollback layer for JavaScript bundles.

01

Connect the app

Install the React Native SDK once and create the channels your team uses for release flow.

                  npx @capgo/cli@latest init
02

Build the JavaScript bundle

Keep the existing React Native build process. The native binary still goes through the app stores when native code changes.

                  npm run build
03

Upload to a channel

Publish the bundle to Development, Beta, or Production from a laptop or CI pipeline.

                  npx @capgo/cli@latest bundle upload --channel=Production
04

Watch adoption

Follow download and install state before expanding a rollout or promoting the bundle further.

                  npx @capgo/cli@latest app debug
05

Rollback if needed

Move the channel back to a previous bundle without asking users to wait for a new binary release.

                  npx @capgo/cli@latest bundle rollback --channel=Production

Monitoring

Know whether the update actually reached users.

A live update system needs more than an upload button. Teams need install state, failure signals, and enough version visibility to decide whether to expand, pause, or roll back.

Downloaded

86%

Ready after restart

71%

Failure rate

0.4%

Production rollout

Bundle v2.8.4 across active app versions

Stable

iOS active

52%

Android active

48%

Rollback target

v2.8.3

Downloaded 86%
Ready after restart 71%
Failure rate 0.4%

CI automation

Fits inside the release workflow you already run.

Use CodePushGo after your bundle build. The live update path stays separate from app signing, native credentials, and store submission.

Release from CI

Run the CLI after your JavaScript bundle build and keep signing, secrets, and app-store credentials outside the live update flow.

Promote, do not rebuild

Move a tested bundle between channels when it is ready instead of generating a new binary for every JavaScript change.

Separate native and JS paths

Native modules, permissions, and SDK upgrades keep their app-store release path. Live updates stay focused on bundle delivery.

Security and control

Live updates need guardrails, not shortcuts.

The point is not to bypass native review for native work. The point is to control compatible JavaScript updates with release history, targeting, and recovery.

End-to-end encrypted updates

Keep update delivery designed so only the intended app clients can decrypt the bundle payload.

Compatible-version targeting

Avoid sending a JavaScript bundle to native app versions that do not have the required binary capabilities.

Auditable release history

Keep a record of uploaded bundles, promoted channels, and rollback decisions for release review.

Clear product boundaries

Use live updates where they are strongest.

CodePushGo is not a plugin marketplace and not a native build replacement. It is the live-update path for compatible JavaScript changes.

Use live updates for

  • JavaScript bug fixes
  • Copy and UI changes shipped in JS
  • Bundled assets
  • Remote configuration handled by the app
  • Small rollout tests and recovery releases

Use app-store releases for

  • Native modules
  • Permissions and entitlement changes
  • SDK upgrades
  • iOS or Android binary configuration
  • Anything requiring new native code

Built for release teams

Focused use cases for teams shipping live updates.

Use CodePushGo where JavaScript delivery creates real production leverage: faster fixes, safer rollout, and faster recovery.

Fix a crash introduced by JavaScript logic
Patch a checkout, login, or paywall screen
Ship copy or visual changes tied to a campaign
Stage a release to beta users before production
Roll back a bad bundle while the team investigates
Keep store releases for native changes only

FAQ

Common release questions, answered clearly.

Does CodePushGo replace app store releases?

No. It handles JavaScript bundle and asset updates. Native changes still go through the Apple App Store and Google Play release process.

Can I use it for React Native hotfixes?

Yes. That is the core use case: publish a compatible JavaScript update to installed apps without waiting for a new binary review cycle.

How do teams keep releases controlled?

Use channels, compatible-version targeting, telemetry, staged promotion, and rollback instead of sending every bundle straight to production.

Can it run from CI/CD?

Yes. The CLI can run from GitHub Actions, GitLab CI, Jenkins, or any pipeline that builds the React Native JavaScript bundle.

Ready for the next JavaScript hotfix

Give React Native releases a recovery path.

Start with one channel, one uploaded bundle, and a rollback plan. Expand the rollout system once the first live update is proven.

Start with the quickstart Review live update features