React Native updates
that heal themselves.
Ship JavaScript fixes without waiting for app-store review. Every release starts small, widens while your app stays healthy, and rolls itself back when it doesn't.
v42 · New checkout
- 1%healthy · 30 min
- 10%crashes 2.4× v41
- 50%skipped
- 100%skipped
Safe by default, from build to phone.
Every release is signed at build, delivered as a tiny patch, tried on the device, and watched until it's at 100%.
Releases that stop themselves.
A guarded release goes 1% → 10% → 50% → 100% on its own. It compares crashes, failed launches and your own events like checkout_success with the previous release, and halts the moment something gets worse.
- Baseline is your last release, not a fixed number
- Alerts to Slack, Discord or any webhook
- Pause, resume or change steps any time
A bad bundle never gets a second launch.
Every update gets a trial launch. If your app doesn't reach its first screen, the phone goes back to the last good bundle by itself. No server round trip, works offline, and the bad bundle is never retried.
Ship only what changed.
Healkite diffs the compiled Hermes bytecode against what each device already runs. Most updates are a few hundred kilobytes, so they arrive fast and cost your users almost no data.
- Typically 80–99% smaller than a full bundle
- sha256-checked after patching, full download as fallback
- Backup CDN if the primary is unreachable
Test a pull request inside the store build.
Every pull request gets a link and a QR code. Testers open it and the app they installed from the store switches to that branch, with a banner to go back. No TestFlight build, no waiting.
How previews work →Even a hacked CDN can't push code.
You sign every bundle with your own key. The server signs every manifest. The app checks both before it downloads a byte, and refuses anything older than what it already trusts.
- ✓Your CI signs the bundleECDSA P-256 · key never leaves CI
- ✓Server signs the manifestno downgrade, no replay
- ✓Device verifies both, then hashes every filesha256 per file · sandboxed paths
Ask your AI assistant to ship.
Connect Claude, Cursor or VS Code to Healkite and work in plain language: set up a project, check how production is doing, roll back a platform, invite a teammate. Every action runs with the key's role.
Set up the MCP server →Find it, fix it, ship it.
While users are still in the app.
When something breaks, Healkite tells you which change did it, lets you see inside one customer's app, and gets the fix to phones in seconds.
Fix the app while it's open.
Checkout breaks during a sale. Publish with --live: a silent push reaches every open app, the fix applies at a safe moment, and each user comes back on the same screen with the same cart.
- Applies in about a second, no app restart by the user
- Keeps the screen, cart and half-filled forms
- Waits while a payment is in progress
✓ Fixed in 0.4 s · same screen · cart kept
Debug the bug only one customer has.
Pick their phone and a line of code. Healkite builds the release they run with your log line in it and sends it to that phone only. The values stream into the dashboard; after an hour it turns itself off.
- No store release, no reinstall, nobody else affected
- Passwords, tokens and card fields are hidden on the phone
Found it: expired trials lose their cart.
Roll back the PR that broke it. Keep the other 11.
When a release stops, Healkite matches the new crashes to the exact lines each pull request changed. Roll back only that PR: your CI rebuilds the release without it and ships the rest, guarded, and opens a revert PR.
How it finds the culprit →PR #381 changed CartScreen.tsx:142, where 213 new crashes happen.
Know what Apple and Google will reject, before they do.
healkite store-check scans your project for the usual rejection reasons: missing permission texts, the privacy manifest, login and payment rules, account deletion, Android's target SDK. Every update also gets a verdict on what's allowed over the air.
Try the fix on your own phone first.
Pick phones by device ID and only those get the update, in the app installed from the store. Check the fix on your phone, send it to the customer who reported the bug, then release it to everyone.
- No test build, no TestFlight, no separate channel
- Everyone else keeps the version they run
- Up to 100 phones per release, with an optional end date
Fix confirmed on both phones. Nobody else touched.
Silent by default. Ask when it matters.
Most fixes install quietly on the next launch. For a redesign or a change people should know about, mark the release "Ask the user": the app shows your release notes with Update now and Later. Or apply it when the user comes back to the app.
- One line:
<UpdatePrompt />, or your own UI withuseUpdate() - Downloaded before it asks, so Update is instant
- Required updates have no Later
Everything a release team needs.
One command to your first update.
Run npx healkite init in your app. It creates the app and channel, wires iOS and Android (or adds the Expo plugin), adds the update prompt and installs the SDK, and shows every change before making it. Then npx healkite release ships your next fix.
Using CodePush? npx healkite migrate codepush removes it, switches the imports and keeps your code working.
$ npx healkite init Healkite account + create app Shop + create channel production Files ~ android/…/strings.xml CDN, channel, keys ~ android/…/MainApplication.kt load updates ~ ios/Shop/Info.plist CDN, channel, keys ~ ios/Shop/SceneDelegate.swift load updates ~ index.js update prompt Apply these changes? (Y/n) y ✓ Healkite is set up. $ npx healkite release -p ios --guarded
Start free. Pay as you grow.
Unlimited apps, releases and teammates on every plan. Going over never stops your updates: extra devices are $0.30 per 1,000.
Free
1K devices · 10 GB / mo
- Guarded rollouts & rollback
- Diff patches, code signing
- No card needed
Indie
15K devices · 100 GB / mo
- Guarded rollouts & rollback
- Diff patches, code signing
- CLI, MCP, GitHub Action
Starter
50K devices · 250 GB / mo
- Everything in Indie
- A/B experiments
- PR previews, campaigns
Growth Recommended
250K devices · 1 TB / mo
- Everything in Starter
- Instant hotfix by push
- Priority support
Scale
1M devices · 5 TB / mo
- Everything in Growth
- SSO (Okta, Entra, Google)
- Backup CDN, 99.9% SLA
PAY YEARLY · GET 2 MONTHS FREE
Your limits. Your cloud or your own servers.
For banks, healthcare and large teams. Run Healkite with us, or self-hosted on your infrastructure with an offline license, even with no internet access. Self-hosted licenses follow the plans above, billed yearly.
- Cloud or self-hostedDocker or Kubernetes, SQLite or Postgres
- Air-gapped installsOffline license, no calls home
- Single sign-onOkta, Microsoft Entra, Google, any OIDC
- Verified buildsOnly reviewed CI builds can publish
- Audit logWho shipped what, exportable
- Custom SLASecurity review and dedicated support
Same job.
A fraction of the price.
What you'd pay each month for over-the-air updates at the same number of monthly active devices, on each vendor's cheapest plan that covers it.
| Monthly active devices | Healkite | Turbopush | Revopush | Stallion | Expo Update |
|---|---|---|---|---|---|
| 15K | $9Indie | $15Startup | $25Startup | $51Pro, billed yearly · $64 monthly | $79Starter + usage |
| 50K | $19Starter | $40Growth | $25Startup | $51Pro, billed yearly · $64 monthly | $199Production |
| 250K | $69Growth | $80Scale | $100Growing | CustomEnterprise | $1,137Production + usage |
| 1M | $199Scale | CustomEnterprise | $500Professional | CustomEnterprise | $3,774Production + usage |
| Healkite | Turbopush | Revopush | Stallion | Expo Update | |
|---|---|---|---|---|---|
| Free plan | 1K devices · unlimited releases | 2K devices · 20 releases / mo | 1K devices · 10 GB | 10K devices | 1K devices |
| Cheapest paid plan | $9 · 15K devices | $15 · 30K devices | $25 · 50K devices | $51 · 100K devices, yearly | $19 · 3K devices |
| Over your limit | Updates keep working · $0.30 per 1K extra devices | — | $1 per 1K extra devices · $0.03/GB | Overage billed monthly | Per-device usage pricing · $0.10/GiB |
| Single sign-on | Scale, $199/mo | — | Enterprise (custom) | Enterprise (custom) | — |
| Self-hosting | Enterprise | — | Enterprise, your cloud | On-Premise (custom) | — |
| CodePush API compatible | Yes, SDK and CLI | Yes | Yes | — | — |
- Guarded rollouts that halt on crashes or your own events
- On-device rollback after a failed launch
- Diff patches and code signing
- MCP server, CLI and GitHub Action
Prices from each vendor's public pricing page as of November 2026 (Turbopush, Revopush, Stallion, Expo), in USD per month before tax, assuming bandwidth stays within each plan's allowance. "—" means not listed on that vendor's pricing page. Microsoft retired App Center CodePush in March 2025.
Detailed comparisons: vs Expo Updates · vs Revopush · vs Stallion · vs Turbopush · vs Bitrise CodePush · all CodePush alternatives
What replaced App Center CodePush?
Microsoft retired Visual Studio App Center, including CodePush, on March 31, 2025. Healkite is a hosted replacement with the same JavaScript API and CLI verbs, so most apps change the import and keys and migrate in an afternoon.
Is shipping JavaScript over the air allowed by Apple and Google?
Yes, as long as updates don't change your app's primary purpose. Both stores allow interpreted code updates such as JavaScript bundles; native code changes still go through a store build.
What happens if a bad update gets through?
On the phone, a bundle that never reaches your first screen is rolled back on the next launch and never retried. On the server, a guarded rollout stops widening and turns itself off when crashes or your key events get worse than the previous release.
Do I need to rewrite my CodePush code?
Usually you only change the import. The CodePush API and CLI verbs work as before; see the migration guide.
Which React Native versions are supported?
React Native 0.80 and newer with the New Architecture and Hermes, on iOS and Android. Expo apps on SDK 50 and newer use a config plugin.
Does it work with Expo?
Yes, with a config plugin on Expo SDK 50 and newer. Use it instead of expo-updates.
What can't be updated over the air?
Native code: new or upgraded native modules, React Native upgrades, permissions and other changes to the app binary need a store release. JavaScript, TypeScript and bundled assets can be updated over the air.
How much does Healkite cost?
Plans are priced by monthly active devices. Free covers 1,000 devices a month with no card. Indie is $9/month for 15,000, Starter $19 for 50,000, Growth $69 for 250,000 and Scale $199 for 1,000,000. Extra devices on monthly plans are $0.30 per 1,000, yearly billing gives two months free, and the first payment has a 7-day money-back guarantee.
Can I host it myself?
Yes. The same product runs on your own servers: one Docker container, or Kubernetes with our Helm chart, on SQLite or Postgres, even with no internet access. It's free up to 1,000 monthly active devices, and above that the same plans apply, billed yearly (Indie $90, Starter $190, Growth $690, Scale $1,990 a year).
Is the SDK open source?
Yes. The React Native SDK, CLI and MCP server are MIT licensed, so you can read exactly what ships inside your app.
Flutter is next.
Over-the-air updates for Flutter apps, with the same guarded rollouts, automatic rollback and backup CDN. Join the waitlist to get early access and help decide what ships first.
- Update assets, translations and remote config without a store release
- Server-driven screens with Flutter's Remote Flutter Widgets
- One dashboard and CLI for your React Native and Flutter apps