Why Native Developers Need Expo Too
After this chapter you will be able to explain, to a native iOS colleague who has never used React Native, exactly what Expo changes and what it leaves alone. You will know which problems it solves well, which ones it does not solve at all, and how to decide whether a project should start in Xcode or in Expo.
“I already have Xcode, Swift and a working app. What does Expo give me that I do not already have?”
This is a reasonable question, and it deserves a straight answer rather than a sales pitch. The honest summary is:
Expo does not make native iOS development better. It makes cross-platform development better, and it moves the parts of the iOS toolchain that are pure overhead out of your project.
The second half of that sentence is the part native developers usually underestimate. A native iOS project has a fixed setup cost: an Xcode project file, a build configuration, dependency management through CocoaPods or Swift Package Manager, signing, provisioning profiles, a bundle identifier, an app icon, launch screens, and a release process that involves archiving, validating and uploading. None of that is your product. For a single-platform app that already works, Expo mostly moves it around.
For a second platform, a rapid prototype, or a team that needs to ship weekly, it removes a large amount of that overhead.
Expo is four layers, and it helps to keep them apart.
React Native renders real native views. A View becomes a UIView, a Text becomes a UILabel, an image becomes a UIImageView. The result is a native binary with a native accessibility tree, not a web view. This is the layer that makes cross-platform possible.
The Expo SDK is a pinned, tested set of native modules with a consistent JavaScript API. When you run npx expo install expo-camera, the CLI picks the version that matches your SDK rather than the latest one on the registry - a small convenience that prevents a whole category of version-mismatch bugs.
The Expo CLI is the tooling around the project: the development server, the bundler, the app configuration schema, and prebuild, which generates the native Xcode project from your configuration.
EAS is the hosted service: eas build produces signed binaries on a remote machine, and eas update ships JavaScript changes to already-installed apps.
1. One codebase for iOS and Android
The interface and the application logic are written once. Platform differences are handled at the edges, through platform-specific files and a small number of native modules.
// Button.ios.jsx renders the iOS variant, Button.android.jsx the Android one,
// and Button.jsx the shared fallback.
import { Pressable, Text, StyleSheet } from 'react-native';
2. A build service that does not need your Mac
eas build runs the compile, signing and packaging on Expo’s infrastructure. A machine without Xcode can produce a signed iOS archive, which matters for teams that do not all own Macs, for CI, and for building release candidates from a tagged commit.
eas build --platform ios --profile production
3. Over-the-air updates
JavaScript and asset changes can be pushed to installed apps without a store review. This is the feature native teams most often miss when they compare the two worlds, because in native iOS the equivalent operation - pushing code - is not possible outside the App Store.
eas update --branch production --message "Fix the checkout total rounding"
The catch is honest and important: iOS requires that an update only changes JavaScript and assets. Anything that touches native code - a new native module, a changed permission, a new entitlement - still needs a new binary and a store release.
4. A large, coherent module ecosystem
There are hundreds of maintained Expo modules covering the things native apps always need: camera, notifications, location, secure store, image manipulation, audio, calendars, Bluetooth, haptics. The value is not the count; it is that they share one API style and one version policy, so they do not fight each other.
5. A real escape hatch
Expo is not a walled garden. When you need native code, you write native code - in Swift or Kotlin - and expose it to JavaScript through the Expo Modules API. The React Native core still supports “legacy” native modules too, so a large body of existing native code can be reused.
6. A configuration-driven native project
Your native project is described by a JavaScript configuration file rather than by hand-edited project settings.
{
"expo": {
"name": "Field Notes",
"slug": "field-notes",
"ios": {
"bundleIdentifier": "com.example.fieldnotes",
"supportsTablet": true
},
"plugins": ["expo-camera", "expo-media-library"]
}
}
npx expo prebuild regenerates the ios/ and android/ directories from that file. You can commit the generated project, edit it freely, and run prebuild again to re-sync it after a configuration change.
Coming from Xcode, the hardest part is not the syntax; it is the shift in what you consider the source of truth.
| Xcode habit | Expo habit |
|---|---|
The .xcodeproj is the project | app.json or app.config.ts is the project |
| Build settings are edited in a GUI | The same settings are declared in a configuration file |
| Dependencies come from CocoaPods or Swift Package Manager | Dependencies come from npm and are configured by plugins |
| You build and run through Xcode | You run npx expo start and the bundler serves the app |
| Release means archiving in Xcode | Release means eas build and eas submit |
The last row is the one that surprises people most. With Expo, the release path is a command line and a service. You can still open the generated ios/ directory in Xcode, but you rarely have to.
- It does not replace native iOS. Swift remains the right tool for anything performance-critical or deeply integrated with the system: a Metal renderer, a custom text engine, a low-latency audio pipeline.
- It does not remove the Apple ecosystem rules. App Review, privacy manifests, the 30 percent store fee and the annual membership all still apply. Expo makes the build easier, not the rules different.
- It does not eliminate native work. Adding a native module still means writing native code and rebuilding the app. What changes is that the rebuild can happen in the cloud.
- It is not automatically faster for a single-platform app. For an iOS-only product with a small team, the extra layer of React Native is a cost with no offsetting benefit.
Choose Xcode and native code when any of these is true:
- the app is iOS-only and will stay iOS-only;
- the product depends on a platform framework that has no React Native equivalent and no third-party module;
- you need a performance profile that only native code can deliver;
- the team has no JavaScript experience and no intention of gaining any;
- the app must support very old iOS versions with strict binary size limits.
Choose Expo when at least two of these are true:
- a second platform is on the roadmap;
- the team wants to iterate on the interface many times a day;
- most of the product is standard mobile functionality that already has a module;
- the release cadence needs to be weekly or faster, or the team needs over-the-air fixes;
- the team is small and cannot afford a dedicated build and release engineer.
# Scaffold a project from the default template.
npx create-expo-app@latest field-notes
cd field-notes
# Install a native module, with the version matched to your SDK.
npx expo install expo-camera
# Start the development server.
npx expo start
Then press i for the iOS simulator, or scan the QR code with Expo Go on a device.
A minimal screen looks like this:
import { StatusBar } from 'expo-status-bar';
import { Pressable, StyleSheet, Text, View } from 'react-native';
export default function App() {
return (
<View style={styles.container}>
<Text style={styles.title}>Field Notes</Text>
<Pressable style={styles.button} onPress={() => console.log('tapped')}>
<Text style={styles.buttonLabel}>Add an entry</Text>
</Pressable>
<StatusBar style="auto" />
</View>
);
}
const styles = StyleSheet.create({
container: { flex: 1, alignItems: 'center', justifyContent: 'center' },
title: { fontSize: 24, fontWeight: '600' },
button: { marginTop: 16, paddingVertical: 12, paddingHorizontal: 20 },
buttonLabel: { fontSize: 16, color: '#ffffff' },
});
That is a complete screen, with layout and styling, in one file.
You are the iOS lead on a team of six. The product is an internal field-service tool: technicians photograph equipment, record notes offline, and sync when they get back to a network. There is also an Android version already in the backlog, written by a team that knows Kotlin but not JavaScript.
Decide whether to build the next version in native iOS, in Expo, or in a hybrid - and name the one thing that would change your answer.
Approach:
Weigh the two forces in the question against each other. The offline requirement plus camera and the planned Android version both pull towards cross-platform. The team’s skills pull the other way: if nobody writes JavaScript, the React Native part will be slow and error-prone, and a hybrid introduces two toolchains at once. The decision should follow from which force is stronger, and the answer should name the condition that would flip it.
Steps:
- Check the platform pressure. An Android version is already in the backlog. That alone makes two codebases a real cost, because every product change must be written twice.
- Check the module coverage. Camera, offline storage and sync all have mature React Native equivalents:
expo-camera,expo-sqliteorexpo-file-systemfor local storage, and a background sync task for the upload. None of these requires custom native code, which removes the usual reason a native team keeps a native codebase. - Check the team cost. The Kotlin team does not know JavaScript, and you do not have a React Native hire. React Native is a JavaScript framework, so the whole UI layer is new for everyone except possibly one person on the team. This is the strongest argument against Expo.
- Compare with the alternative. Staying native means writing the Android version by hand as well, and paying the “Android team knows Kotlin” benefit only on one platform. You would have two codebases either way.
- Find the flip condition. The decision changes as soon as one of the following becomes true: a React Native developer joins the team, the Android version is dropped from the roadmap, or a core feature turns out to need a custom native module that neither platform’s React Native ecosystem provides.
Answer:
Build the next version in Expo, with these conditions attached:
- The iOS app is written in React Native from day one, so the shared codebase is real rather than aspirational.
- The existing native iOS code is not thrown away; the parts that are still needed - the sync protocol, the credential handling, any performance-sensitive image processing - are exposed as native modules through the Expo Modules API and reused.
- The team invests in one or two days of JavaScript and React training, because otherwise the delivery risk sits entirely on the iOS lead.
- The offline layer is built with a single JavaScript API and thin native adapters, so the Android and iOS behaviour cannot drift apart.
The one thing that changes the answer: if the offline sync logic turns out to depend on a platform framework with no React Native equivalent - a specific background transfer mode, a restricted entitlement, a vendor SDK that only ships an iOS binary - then the shared-codebase argument collapses, and native iOS plus a separate Kotlin app is the better plan. The second thing that changes it is a React Native hire joining the team, which makes the hybrid cost much easier to carry.
