React Native development: two apps, one codebase
Gjethe builds iOS and Android apps with React Native and TypeScript, using Expo for speed and native Swift or Kotlin modules where an app needs deeper device access. We also take over existing React Native apps: upgrading versions, fixing crashes and performance problems, and continuing development.
- Free first consultation
- Written quote for your project
- Flexible payment milestones
At a glance
- Language
- TypeScript
- Workflow
- Expo or bare React Native
- Native code
- Swift and Kotlin modules when needed
- Also
- Upgrades and app rescues
Definition
What is React Native development?
React Native is an open-source framework from Meta for building iOS and Android apps with JavaScript or TypeScript and React. It renders real native interface components, so one codebase produces two genuinely native apps.
React Native lets one team build both apps, ship features to both platforms at once and share logic with a React web app. It's used in production by companies such as Meta, Microsoft, Shopify and Discord. This page is for teams who already know they want React Native, or who have an existing React Native app that needs care. If you're still deciding on an approach, start with mobile app development.
Who is it for?
Teams launching on both platforms
You need iOS and Android at the same time without funding two separate teams.
Companies with React web teams
Your web developers know React; React Native lets them share knowledge, tooling and some logic with the mobile app.
Owners of an ageing React Native app
The app is several versions behind, crashes on new devices or can't be built anymore. We bring it back to health.
Startups needing a dedicated mobile team
A focused team to own the mobile app while your engineers handle the backend.
What's included, and what you keep
What's included
- Architecture and project set-up with TypeScript
- Expo or bare workflow, chosen per project
- Navigation, state management and data fetching
- Native modules in Swift and Kotlin where needed
- Push notifications and deep links
- In-app purchases with RevenueCat
- Offline-first storage and sync
- Maps, camera, biometrics and device sensors
- Over-the-air updates for JavaScript changes
- Automated builds and store submissions with EAS
- Crash reporting and performance monitoring
- Upgrades of existing apps to current versions
What you receive
Handed over at the end. Yours to keep.
- iOS and Android apps on the stores
- Source code in your repository
- Build and release pipeline
- Over-the-air update channel
- Technical documentation
Expo or bare React Native?
| Expo (with prebuild) | Bare React Native | |
|---|---|---|
| Set-up and builds | Managed tooling and cloud builds | Manual native project configuration |
| Native code | Supported through config plugins and custom modules | Full direct control |
| Updates | Expo Updates built in | Set up separately |
| Our default | Yes, for most new apps | For apps with unusual native SDK requirements |
How do we rescue an existing React Native app?
Apps that haven't been updated for a while tend to fail in predictable ways: builds break because tooling moved on, libraries are abandoned, new OS versions crash old code and the stores demand newer target versions.
We start by getting the app building again and auditing dependencies. Then we upgrade React Native step by step rather than in one leap, replace abandoned libraries, fix crashes reported in monitoring and move to Expo tooling where it simplifies builds.
Once the app is stable and current, development continues on a healthy foundation, with automated builds so it doesn't drift out of date again.
Where React Native performs well, and where we add native code
Business and consumer apps
Forms, lists, feeds, booking flows and dashboards perform excellently with native components.
Animation
Reanimated runs animations on the native thread for smooth gestures and transitions.
Camera and media
Well-supported through mature libraries, with native modules for specialised processing.
Heavy graphics
3D-intensive or game-like apps usually belong in native code or a game engine.
How React Native development works, step by step
Every step has a clear output you can review. Timing is agreed in your quote.
- 1
Assessment
For new apps, scope and architecture; for existing apps, a code, dependency and crash audit.
- 2
Foundation
Project structure, navigation, data layer, environments and automated builds.
- 3
Feature development
Features built and shipped to testers on both platforms through TestFlight and Play testing tracks.
- 4
Native integration
Swift and Kotlin modules for anything the JavaScript layer can't reach.
- 5
Quality
Device testing, performance profiling and crash monitoring.
- 6
Release
Store submission, then over-the-air updates for small fixes between releases.
Tools, and what shapes your quote
Pricing is based on your project and agreed in your quote. These are the things that move it.
| Factor | Why it matters |
|---|---|
| Scope of features | Screens, flows and backend work drive most of the cost, as with any app. |
| Native modules | Custom Swift or Kotlin code for specialised SDKs adds work on both platforms. |
| Offline and sync | Local-first data with conflict handling takes more design and testing. |
| State of an existing app | Old versions and abandoned libraries make upgrades and rescues more involved. |
| Shared code with web | Sharing logic with a React web app saves time later but needs planning up front. |
| Area | Tools |
|---|---|
| Core | React Native, TypeScript, Expo, EAS Build and Submit |
| App architecture | React Navigation, Expo Router, Zustand, Redux Toolkit, TanStack Query |
| UI & animation | Reanimated, Gesture Handler, native components |
| Native | Swift, Kotlin, Expo Modules API |
| Services | Firebase, OneSignal, RevenueCat, Sentry |
Common mistakes to avoid
What we see go wrong most often, and how a good project avoids it.
Letting versions fall behind
Skipping React Native upgrades for years turns a routine task into a rescue project. Upgrade regularly.
Too many unmaintained libraries
Each third-party library is a dependency you must keep compatible. Choose well-maintained ones and few of them.
Doing heavy work on the JavaScript thread
Large lists, animations or data processing on the main JS thread cause stutter. Use the right tools for each.
Shipping native changes over the air
OTA updates are for JavaScript and assets only; native changes must go through the stores.
Frequently asked questions
Is React Native as fast as a native app?
For most apps users can't tell the difference, because React Native renders real native components. Performance-critical parts can be written as native modules in Swift or Kotlin.
Expo or bare React Native?
We start with Expo for most apps because it speeds up development, builds and updates. We use the bare workflow, or Expo with custom native code, when an app needs SDKs Expo doesn't cover.
Can you take over an existing React Native app?
Yes. We audit the codebase, update dependencies and the React Native version, fix stability issues and continue development.
Can you push updates without a store review?
JavaScript and asset changes can ship over the air with Expo Updates. Native code changes still need a normal store release.
Can we share code with our React website?
Yes. Business logic, types, API clients and validation can be shared in a monorepo; interface code is usually platform-specific.
Does React Native support tablets and foldables?
Yes. Layouts can adapt to screen size, and we design dedicated tablet layouts when the product benefits.
Will the app look the same on iOS and Android?
It can share a brand look while respecting each platform's conventions, such as navigation patterns and system controls.
What about the New Architecture?
New apps use React Native's New Architecture by default. For older apps, we migrate as part of upgrades once their libraries support it.
Do you also build the backend?
Yes, APIs, databases, authentication and admin tools, or we integrate with your existing backend.
How do you test React Native apps?
With unit tests for logic, component tests for screens, end-to-end tests for key flows using tools such as Maestro or Detox, and manual testing on real iOS and Android devices before each release.
Can you improve a slow React Native app?
Yes. We profile the app to find the cause (heavy lists, unnecessary re-renders, large images or work on the JavaScript thread) and fix each one, measuring the improvement on real devices.
Related services
Mobile App Development
iOS and Android apps, from design to store launch.
iOS App Development
iPhone and iPad apps that follow Apple's guidelines.
Android App Development
Android apps for the full range of devices.
Custom API Development
Documented REST, GraphQL and WebSocket APIs.
QA & Software Testing
Manual and automated testing across browsers and devices.
React Native Development by industry
Build your React Native app.
Tell us what you need. You get an honest assessment, a clear plan and a written quote. The first consultation is always free.
- What happens next
- 1You tell us what you need
- 2We aim to reply within 24 hours with questions
- 3You get a written quote for your project