Skip to content

Service · Mobile

React Native Development

Commission a React Native app when the framework is settled and you want it built properly: typed, on the current architecture, with native code where JavaScript should not go. We build new apps, take over existing ones and carry stalled projects across major version upgrades.

Built on the New Architecture with Hermes

Swift and Kotlin modules written where needed

EAS or Fastlane pipelines your team can run

Deliverables

What a React Native development engagement delivers.

01Delivered

A typed React Native codebase

TypeScript throughout, a folder structure organised by feature, navigation with React Navigation or Expo Router, and server state handled by a query library rather than hand-rolled caching.

02Delivered

Native modules where JavaScript stops

Turbo Modules or Expo Modules written in Swift and Kotlin for SDKs without bindings, background tasks, widgets or hardware access, each with its own tests and a short readme.

03Delivered

Build and update pipeline

EAS Build or Fastlane producing signed binaries on every merge, plus an over-the-air update channel for JavaScript-only fixes, gated by runtime version so updates never land on an incompatible binary.

04Delivered

Performance baseline

Startup time, list scrolling and memory measured on a low-end Android handset and an older iPhone, recorded so future changes can be compared against a known starting point.

05Delivered

Upgrade notes

A record of the React Native and Expo SDK versions in use, the libraries that pin them, and the steps for the next upgrade, so the app does not drift years behind.

Early decisions

Technical decisions we settle early in React Native development.

01Decided

Expo or bare workflow

Expo with development builds and config plugins now covers most apps, including custom native code. A bare project still suits teams with heavy existing native code or build steps Expo cannot express. We choose per project.

02Decided

New Architecture readiness

Fabric and Turbo Modules are the default in current releases. We audit every third-party library for support before committing, because one unmaintained package can hold back an upgrade.

03Decided

What may change over the air

Over-the-air updates can fix JavaScript and assets without review, within store rules on changing an app’s purpose after approval. We agree which kinds of change go out this way and which wait for a store release.

04Decided

Sharing code with your React web app

Business logic, validation, API clients and types can be shared through a monorepo. Components usually cannot, because React Native renders native views rather than DOM elements. We decide the boundary up front.

05Decided

Animation and gesture approach

Reanimated and Gesture Handler run animation work on the UI thread. Choosing them early avoids rewriting interactions that stutter once real data and slower devices are involved.

06Decided

State and data layer

Server data, local preferences and offline queues need different tools. Mixing them in one global store is a common reason React Native apps become hard to change, so we separate them from the first screen.

Engagement

How a React Native development engagement runs.

  1. 01Phase 1

    Codebase or requirements audit

    For an existing app we review versions, libraries, native code and crash data. For a new one we review the feature list against what React Native reaches easily and what needs native work.

  2. 02Phase 2

    Foundation and native spikes

    Project setup, navigation, authentication, the build pipeline and any risky native module are built first, proving the hardest integration on real devices before feature work begins.

  3. 03Phase 3

    Feature delivery with device checks

    Features ship behind flags in short cycles, with each build checked on physical iOS and Android devices, not only simulators, because gesture feel and keyboard handling differ.

  4. 04Phase 4

    Release, update channel and handover

    Store releases go out in stages, the over-the-air channel is switched on with rollback tested, and your team receives the pipeline, upgrade notes and a walkthrough of the native modules.

Fit

When React Native is the right choice.

01Good fit

Your team already writes React

Web engineers who know React, TypeScript and its tooling can read, review and eventually maintain the app, which shortens the path to owning it in-house.

02Good fit

An existing React Native app is stuck

Apps several versions behind, blocked by abandoned libraries or crashing after an upgrade attempt benefit from a team that has carried projects across major releases.

03Good fit

You want fast fixes between store releases

Products that change copy, flows and pricing often gain from a controlled over-the-air channel for JavaScript changes, with store releases kept for native updates.

React Native today is not the React Native of old

Much of the criticism people repeat about React Native dates from the asynchronous bridge, where every call between JavaScript and native code was serialised and queued. The New Architecture replaces that with JSI, letting JavaScript hold references to native objects and call them directly, alongside the Fabric renderer and Turbo Modules.

In practice that means smoother gestures, synchronous layout where it is needed and native modules that load lazily. It also means some older libraries no longer work, which is why we audit dependencies before starting rather than discovering a blocker mid-build.

Expo has changed the default

Expo used to mean giving up custom native code. With development builds, config plugins and the Expo Modules API, that trade-off has largely gone, and the React Native team now recommends starting new apps with a framework such as Expo. We still choose a bare setup when a product carries significant existing native code or unusual build requirements.

Knowing when to write Swift or Kotlin

Good React Native apps contain some native code. Payment terminals, Bluetooth peripherals, home-screen widgets, background location and vendor SDKs without bindings all call for a module written in the platform language. We treat these modules as first-class parts of the app, with tests and documentation, so they do not become a corner only one person understands.

Over-the-air updates need rules

Shipping JavaScript fixes without a store review is one of React Native’s real advantages, and also an easy way to break an app. An update built for one native runtime can crash on another. We tie each update to a runtime version, release it to a small share of users first, and keep a tested rollback, so a bad bundle can be withdrawn quickly.

Staying current after we leave

React Native moves quickly, and apps that skip several releases end up facing a painful jump. We leave a written record of versions, the libraries most likely to block an upgrade and the order to tackle them, so your team can keep the app current in small steps rather than a large rescue later.

FAQ

Questions to resolve before the build.

01What affects the cost of a React Native project?

The number of screens and roles, how much native code is needed for SDKs or hardware, whether the backend exists, how many third-party libraries need replacing for New Architecture support, and, for an existing app, how far behind its versions are. An upgrade across several major releases can be a project in itself.

02How long will our React Native work take?

Duration follows scope, native integration risk, the state of an inherited codebase and how quickly builds are reviewed on your side. We fix a plan after the audit and the first native spike, because those two steps uncover most of what changes the estimate.

03What exactly is handed over?

The repository with full history, native module sources, the EAS or Fastlane configuration, signing credentials stored in your accounts, the over-the-air channel settings, the performance baseline and the upgrade notes for the next version jump.

04Who owns the code and any native modules you write?

You own all code written for the engagement, including native modules. For the npm dependencies we pull in, your legal team gets a generated licence report listing each package. Nothing is held back as a proprietary component.

05How do we accept each delivery?

Features are accepted against criteria agreed beforehand, tested by your team on installable builds for both platforms. An upgrade is accepted when the app passes the agreed regression checklist on the new version and the performance baseline has not slipped.

06What is not included?

Backend development, visual design and post-launch support are separate unless written into the scope. We also do not use over-the-air updates to change what an app fundamentally does, because store rules forbid it.

Primary sources

References behind this page

Dated official documentation, standards, and research that support the factual claims on this page.

  1. 01
    React Native documentation

    The official guide to React Native, including the New Architecture and native modules.

  2. 02
    Expo: EAS Update

    How over-the-air updates are published, targeted by runtime version and rolled back.

How to read this page

Scope, cost and timeline figures are planning guidance until confirmed in a written proposal. Diagrams and screens are illustrations, not client deliverables, and source-code rights and handover follow the signed agreement. See the delivery process and the full disclaimer.

Next decision

Turn the brief into an accepted product scope.

Define outcomes, constraints, evidence, rights and handover before delivery begins.

Commercial rights, repositories, environments, documentation, acceptance and handover remain contract-defined.