How to Update React Native Apps Without the App Store

Introduction: The App Store Bottleneck

You've just discovered a critical bug in production. Users are reporting crashes, your error tracking is lighting up, and you need to push a fix immediately. There's just one problem: Apple's App Store review takes 1-7 days. Google Play isn't much better, averaging 1-3 days for review.

For React Native developers, this wait is more than an inconvenience — it's a business risk. Lost revenue, frustrated users, and 1-star reviews pile up while you wait for a reviewer halfway around the world to approve your one-line fix.

But what if you could skip the review process entirely?

That's exactly what Over-the-Air (OTA) updates enable. In this guide, you'll learn how to push instant updates to your React Native app — safely, compliantly, and without waiting for App Store or Google Play approval.

What Are OTA Updates?

Over-the-Air (OTA) updates allow you to update the JavaScript bundle and assets of your React Native app without submitting a new binary to the App Store or Google Play. When a user opens your app, the SwiftPatch SDK checks for available updates, downloads the new JavaScript bundle in the background, and applies it on the next app restart.

How it works under the hood:

1. Developer pushes update via CLI
2. SwiftPatch generates a differential patch
3. User opens app → SDK checks for updates
4. Patch downloaded in background (200KB avg)
5. On next restart → new code is loaded
6. App runs the updated JavaScript bundle

• Native code (Objective-C/Swift for iOS, Java/Kotlin for Android) — compiled and shipped as a binary
• JavaScript code (your React components, business logic, styles) — interpreted at runtime

OTA updates replace the JavaScript bundle only. The native binary stays the same, which is why this approach is allowed by both Apple and Google.

Apple App Store Guidelines: Section 3.3.2

Apple explicitly allows OTA JavaScript updates under App Store Review Guidelines Section 3.3.2:

"Interpreted code may be downloaded to an Application but only so long as such code: (a) does not change the primary purpose of the Application by providing features or functionality that are inconsistent with the intended and advertised purpose of the Application as submitted to the App Store, (b) does not create a store or storefront for other code or applications, and (c) does not bypass signing, sandbox, or other security features of the OS."

What this means in practice:

• You CAN update JavaScript code, React components, and bundled assets
• You CAN fix bugs, change styles, update text, and tweak logic
• You CANNOT change the fundamental purpose of your app
• You CANNOT bypass iOS security features
• You CANNOT add entirely new native functionality

SwiftPatch is designed to work within these guidelines. The SDK only updates JavaScript bundles and static assets — never native code.

Google Play Store Policy Compliance

Google Play's Developer Program Policy is even more permissive regarding OTA updates. Google allows apps to update code outside of the Play Store as long as:

• Updates don't violate Google Play policies
• Updates don't introduce malicious behavior
• The app continues to comply with all applicable policies

Google's primary concern is malware and deceptive behavior, not JavaScript updates for bug fixes and improvements. React Native OTA updates are fully compliant as long as you're not using them to circumvent policy requirements.

What You CAN vs. CANNOT Update

Understanding the boundary between JavaScript and native code is crucial.

• React components and screens
• Business logic and data processing
• Styles, layouts, and animations
• Navigation logic
• API calls and network logic
• Images and static assets bundled with JS
• Text, translations, and copy
• Feature flags and configuration

• Native modules (Objective-C, Swift, Java, Kotlin)
• New native dependencies (npm packages with native code)
• App permissions (camera, location, push notifications)
• iOS/Android configuration files (Info.plist, AndroidManifest.xml)
• App icon or launch screen
• Minimum OS version requirements

Step-by-Step Setup with SwiftPatch

Step 1: Install the SDK

npm install swiftpatch

Step 2: Initialize SwiftPatch in Your App

// App.tsx
import { SwiftPatch } from 'swiftpatch';

// Initialize as early as possible
SwiftPatch.init({
  deploymentKey: 'YOUR_DEPLOYMENT_KEY',
  autoRollback: true,         // Automatically rollback on crash
  checkFrequency: 'ON_APP_RESUME', // Check for updates when app resumes
});

export default function App() {
  return (
    // Your app components
  );
}

Step 3: Configure Update Strategy

SwiftPatch.init({
  deploymentKey: 'YOUR_DEPLOYMENT_KEY',
  autoRollback: true,
  updateStrategy: 'IMMEDIATE', // Apply immediately on download
  // Or use 'ON_NEXT_RESTART' for less intrusive updates
  // Or use 'ON_NEXT_RESUME' for a balance
});

Step 4: Deploy Your First OTA Update

# Login to SwiftPatch
swiftpatch login

# Deploy to iOS
swiftpatch release --platform ios --description "Fix: Login button crash on iOS 18"

# Deploy to Android
swiftpatch release --platform android --description "Fix: Login button crash"

# Or deploy to both
swiftpatch release --platform all --description "Fix: Login button crash"

That's it. Your update is live in under 60 seconds. No App Store review. No waiting.

Real-World Scenarios

Scenario 1: Emergency Hotfix

Your app crashes for users on iOS 18.2 due to a null pointer in the login flow. With SwiftPatch:

# Fix the bug in code
# Test locally
# Deploy immediately
swiftpatch release --platform ios --description "Hotfix: null check in login flow"

Time from fix to production: under 2 minutes.

Scenario 2: A/B Testing

You want to test a new checkout flow with 10% of users:

swiftpatch release --platform all --rollout 10 --description "A/B: New checkout flow"

Monitor metrics, then expand or roll back based on results.

Scenario 3: Feature Flags

Push configuration updates to enable/disable features without code changes:

// Your feature flag logic lives in JS — fully OTA updatable
const features = {
  newDashboard: true,
  darkMode: false,
  socialLogin: true,
};

Scenario 4: Content Updates

Update marketing copy, translations, or in-app messaging instantly:

swiftpatch release --platform all --description "Updated onboarding copy for Q1 campaign"

Best Practices for Production

1. Always Use Staged Rollouts

Never push to 100% of users immediately. Start small and expand:

swiftpatch release --platform all --rollout 1   # 1% of users
# Monitor for 1 hour
swiftpatch promote --rollout 10                   # 10% of users
# Monitor for 2 hours
swiftpatch promote --rollout 100                  # All users

2. Enable Automatic Rollback

SwiftPatch can detect crashes within 30 seconds of an update and automatically roll back:

SwiftPatch.init({
  autoRollback: true,
  healthCheckTimeout: 30000,
});

3. Sign Your Bundles

Use cryptographic bundle signing to prevent tampering:

swiftpatch release --platform all --sign --private-key ./keys/private.key

4. Test in Staging First

swiftpatch release --platform all --environment staging
# QA tests in staging
swiftpatch release --platform all --environment production

5. Monitor Update Adoption

Track how many users have received your update:

swiftpatch status --deployment latest

Conclusion

OTA updates are the single biggest productivity boost for React Native teams. Instead of waiting days for App Store review, you can push critical fixes in minutes. SwiftPatch makes this process safe with automatic rollback, staged rollouts, and bundle signing — all while staying fully compliant with Apple and Google's guidelines.

Stop waiting for App Store review. Start shipping updates instantly.

Get started with SwiftPatch for free →