Expo for React Native: The Managed Workflow in 2026

Expo is now the official starting point for new React Native projects, recommended by the React Native team itself. This guide covers how the managed workflow and EAS toolchain actually operate in 2026, what it costs, and the honest tradeoffs for founders and CTOs deciding whether Expo fits their build. No boilerplate, just the decisions you need to make.

9 min read9 sectionsJune 20, 2026

Kostadin Stamboliev

Founder and Imaginator

LinkedIn

Founder and Imaginator at Pineido. Practitioner across IT consulting, app and web development, technical SEO, and AI / automation. Ships production code in 30-day sprints with fixed scope and clear ownership.

Why Expo Is Now the Default Starting Point

In 2024, the React Native team officially updated their docs to recommend Expo as the default way to start a new project. That was not a minor footnote. It signaled that the ecosystem had converged on Expo as the baseline, and raw React Native CLI is now the fallback for teams with specific native requirements, not the starting point.

The practical reason is straightforward. Setting up a React Native project from scratch means installing Xcode, configuring the iOS Simulator, setting up Android Studio and a JDK, managing CocoaPods, and keeping all of it in sync as dependencies update. For a two-person startup, that setup regularly costs two to three days before a single line of app logic is written.

Expo's managed workflow collapses that to a single npx create-expo-app command. You get a project that runs in Expo Go on a physical device in under ten minutes. The tradeoff is that you are working within Expo's supported native module set. For most apps: forms, maps, push notifications, camera, local storage, payments via WebView, that set covers everything you need.

The managed workflow is not a toy. Apps on the App Store and Play Store with tens of thousands of users run on it. The question is not whether it is production-grade. It is whether your specific feature set stays within the managed boundary.

EAS Build: Cloud Compiles Without Local Toolchains

EAS Build is the part of Expo's infrastructure that replaces your local Xcode and Android Studio setup with a cloud build pipeline. You define a build profile in eas.json, run eas build, and Expo's servers compile the native binary for you. The resulting .ipa and .aab files come back as download links.

The concrete payoff: a developer on a Windows machine can produce a valid iOS build. A new engineer joins the team and does not spend their first day wrestling with certificate provisioning. Your CI pipeline does not need a macOS runner for iOS builds.

Prebuild is the mechanism underneath this. When you run eas build, Expo generates the native iOS and Android project files from your JavaScript config, app.json, and installed packages. That generation step takes two to five minutes. The full cloud compile on top of it takes eight to fifteen minutes for a typical project. Compare that to thirty to sixty minutes on a local machine with a warm cache.

EAS Build handles code signing automatically. Expo can manage your provisioning profiles and certificates, rotating them and storing them in its secure credential storage. You can also bring your own credentials if your organization requires it. Either way, the No valid profiles error that has ended many iOS deploy attempts at midnight is no longer your problem to debug.

EAS Submit and EAS Update: The Full Deployment Loop

EAS Build gets you a binary. EAS Submit gets it into the stores. After a successful build, eas submit --platform ios uploads the .ipa directly to App Store Connect and starts the submission process. The same command works for Play Store with the .aab. You still need your developer accounts and the standard review process applies, but the manual upload step and the Transporter tool headaches disappear.

EAS Update is where the managed workflow earns its keep operationally. Because React Native apps split into a native binary layer (which requires a review cycle) and a JavaScript bundle (which does not), you can push JavaScript updates directly to users over the air. When you ship a bug fix as an EAS Update, users on active sessions receive the patch on their next app launch, with no App Store review and no user action required. The turnaround from merge to users receiving the fix is typically under ten minutes.

This matters at two specific moments. First, when you ship a critical bug in a release and need to contain it before it compounds. Second, during early product iteration when you are running weekly or biweekly cycles and waiting four to seven days per App Store review would kill your velocity.

EAS Update respects branch logic, so you can stage updates to a beta channel before rolling to production. Rollback is a single command.

What Expo Costs in 2026

Expo's pricing has three tiers that matter for decision-making. The free tier covers personal projects and early development: unlimited EAS Builds on a shared queue (slower, typically thirty to sixty minutes), limited EAS Update bandwidth (up to 1,000 monthly active users on OTA), and no priority support.

The Production plan at $99 per month is the baseline for any team shipping to real users. It includes priority build queues (typical queue wait under two minutes), fingerprint-based update targeting, higher Update bandwidth for larger user bases, and team collaboration features. For most funded startups or product teams, this is the plan to start with.

The Enterprise tier is custom pricing, aimed at teams needing dedicated build infrastructure, SLA guarantees, or very high OTA update volume.

For context on total cost of the mobile stack: Apple Developer Program is $99 per year, Google Play is a one-time $25 fee. Add Expo Production at $99 per month and your infrastructure cost for a production mobile app is roughly $110 to $120 per month before any backend or third-party services. That is a very low bar compared to the two to three weeks of DevOps time you would spend building an equivalent CI/CD pipeline from scratch with Fastlane, custom signing scripts, and a macOS CI runner.

Pay-as-you-go build credits are available if your team builds infrequently. At $0.05 per build minute on shared infrastructure, a typical build costs $0.50 to $0.75.

Expo Router and Navigation Performance

Expo Router, now stable and the recommended navigation solution for Expo projects, brings file-system-based routing to React Native, the same mental model as Next.js for the web. You create files in an app/ directory and the routes are inferred. Deep linking, universal links, and web routing (if you target Expo Web) all derive from the same file structure.

For performance, Expo Router uses React Navigation under the hood and supports lazy loading of route components. On a mid-range Android device (Pixel 6a class), initial load of a production Expo Router app with eight to twelve screens is typically under two seconds from cold start, assuming you are not blocking the JS thread with heavy synchronous work on mount.

Fast Refresh is the development-cycle feature that matters daily. Code changes reload in the simulator or device in under one second for most component edits. Full reloads, when the native layer needs to reinitialize, take three to five seconds. Compare that to full Xcode recompile cycles of thirty to ninety seconds for native changes and the development loop advantage becomes concrete.

Expo also ships with Hermes as the default JavaScript engine, which cuts startup time by thirty to fifty percent over the older JSC engine on Android. Cold start is a real user metric and Hermes meaningfully moves it.

When Expo Is the Wrong Choice

Expo's managed workflow has a clear boundary: the native module set it supports. When your feature requirements cross that boundary, you are looking at either ejecting to a bare workflow or using the Expo bare workflow from the start.

The cases where managed Expo is genuinely overkill or the wrong fit:

ARCore or ARKit features. Augmented reality at the native API level requires custom native code. Expo's expo-camera and community AR wrappers cover basic cases, but if you need scene understanding, depth maps, or tight integration with device ML accelerators, you need bare React Native or a dedicated native SDK.

Bluetooth Low Energy (BLE) peripherals. Community packages like react-native-ble-plx work in the bare workflow but require native module linking that is outside the managed workflow boundary.

Teams already comfortable with local builds. If your team has senior iOS and Android engineers, local build toolchains set up, and Fastlane scripts already running, the Expo cloud pipeline adds cost without removing friction for you specifically.

Custom native modules in C++ or Objective-C/Swift that need direct JSI bridging. The new React Native architecture (Fabric, TurboModules) is supported in Expo SDK 50+ via the bare workflow, but complex JSI modules are still easier to develop and test outside the managed layer.

For greenfield apps without these requirements, defaulting to managed Expo and ejecting only if you hit a wall is almost always faster than starting bare.

Ejection: What It Means and When to Do It

Ejection in Expo's terminology means running expo prebuild and committing the resulting ios/ and android/ native directories to your repository. After that point, you manage those directories yourself. You gain full native customization. You lose the ability to use the managed workflow's automatic native project generation.

The important clarification for 2026: ejection is not permanent in the catastrophic way it used to be. If you eject and later discover that an Expo SDK update would have handled your native requirement automatically, you can re-run prebuild to regenerate the native project, though resolving merge conflicts with your custom native code takes care.

The practical decision rule: eject when you need to add a native module that requires manual android/app/build.gradle or ios/Podfile editing and the Expo community has not yet shipped a config plugin for it. The config plugin ecosystem has matured significantly. A growing number of native modules now ship with Expo config plugins, which let the managed workflow apply native modifications at prebuild time without manual native file edits.

Before ejecting, check whether a config plugin exists. Search expo-community-cli or the module's README. If it exists, you can stay in managed. If it does not, the path is clear: eject, add the native code, and continue with the Expo toolchain for builds and updates via the bare workflow.

OTA Updates as an Operational Tool

The ability to push JavaScript updates without store review changes how you operate a mobile product, not just how you fix bugs. Teams that internalize this shift their deployment model in two ways.

First, they decouple the release of backend API changes from mobile releases. You ship a new API endpoint, update the mobile JavaScript to call it, and push an EAS Update. Users get the new behavior without a week-long review cycle. This matters most in the first six months of a product when backend and frontend are moving fast.

Second, they use OTA updates as a rollback mechanism. If a release introduces a regression you did not catch in QA, you can push a rollback update in ten minutes. The alternative, an expedited App Store review, is four to eight hours minimum and not guaranteed. The cost of a bad release in user ratings and churn is hard to quantify but real.

The constraint to keep in mind: EAS Update can only change JavaScript and assets. Any change that requires a new native binary, adding a native module, changing permissions in Info.plist, updating the app icon, must go through a full build and store review. Maintaining discipline about what belongs in a JS update versus a binary release is a process question your team needs to answer explicitly, ideally documented in your deployment runbook.

For most product teams, the right cadence is monthly or biweekly binary releases and on-demand JS updates for fixes and minor feature work.

How Pineido Scopes Expo Builds as a Fixed-Price Sprint

When Pineido evaluates a mobile build, the managed workflow question is one of the first scope gates. If the feature set stays within Expo's native module boundary, we can ship a production-ready iOS and Android app with EAS Build, Submit, and Update fully configured in a 30-day sprint. That includes store submissions, OTA update infrastructure, and CI/CD via EAS. If the spec requires custom native modules outside that boundary, we scope accordingly and size the sprint to include the bare workflow setup and native development time.

The fixed-price model works here specifically because Expo's managed workflow makes the infrastructure scope predictable. Cloud builds, automatic signing, and OTA updates remove the categories of work that routinely cause mobile projects to run over budget. You can see how Pineido scopes mobile development at our Custom App and Web Development page, or if you are still evaluating the overall approach, the MVP Development for Startups page covers how we scope greenfield builds end to end.

Ready to ship?

Tell us where you are stuck. We will review it and send a focused recommendation within one business day.

Get operations insights weekly

Join service-business operators who get one actionable insight on ops, automation, and growth every week.

Checking that you're human. You can send in a moment.

No spam. Unsubscribe anytime.

You’re subscribed! Look for our next issue in your inbox.

Frequently asked questions

How much does EAS Build cost in 2026?

The EAS Production plan costs $99 per month and covers priority build queues, higher OTA update bandwidth, and team collaboration. There is a free tier for development and personal projects, with shared queue builds that can take thirty to sixty minutes. Pay-as-you-go credit is available at roughly $0.05 per build minute for teams that build infrequently, making a typical build cost around $0.50.

How fast can you push a bug fix with EAS Update?

From code merge to users receiving the fix is typically under ten minutes. EAS Update packages your JavaScript bundle and assets, publishes them to Expo's CDN, and users pick up the update on their next app launch. No App Store review is involved because you are only updating the JavaScript layer. For critical production bugs, this is the fastest fix path available in mobile development.

What is the difference between Expo managed workflow and bare workflow?

In the managed workflow, Expo generates and owns the native `ios/` and `android/` directories. You never edit them directly. In the bare workflow, you run `expo prebuild` and commit those directories, then manage them yourself. The managed workflow is simpler and fully EAS-compatible. The bare workflow gives full native access. Most teams start managed and move to bare only when they need a native module without a config plugin.

Can you go back to managed Expo after ejecting?

You can re-run `expo prebuild` to regenerate the native directories from your config, but any manual changes you made to the native files will need to be merged in. In practice, recovering a heavily customized bare project back to managed is painful. The better approach is to delay ejection until you are confident you need it, and document every manual native change so re-merging is manageable if you ever need to regenerate.

Do OTA updates with EAS Update violate App Store rules?

No, as long as you stay within Apple's guidelines. The App Store allows JavaScript-only OTA updates for React Native apps. The restriction is that you cannot use OTA updates to ship fundamentally different app functionality or bypass review for changes that alter the app's core purpose. Bug fixes, UI changes, content updates, and minor feature additions within the existing app description all fall within the allowed scope.

Should new React Native projects use Expo or React Native CLI in 2026?

Start with Expo unless you have a specific reason not to. The React Native team officially recommends Expo as the default starting point. React Native CLI is the right choice only if you are integrating with an existing native app, need native modules outside Expo's support boundary from day one, or have a team already set up with local native toolchains. For greenfield projects, Expo is faster to start and cheaper to maintain.