Skip to content
STACK IT FIRST
Install the skills
02 · Mobile · Scale · Consumer

React Native with native modules, or native apps behind one API

Cross-platform where it works, native where it must, and a generated API client so both share one contract.
Agent fit3/5 Scale · Run it for many Reviewed

The stack

Framework
React Native (bare or Expo with custom dev client), with Swift and Kotlin modules where needed
Data
The product API with a CDN and edge caching for media
Auth
The product's provider
Hosting
EAS or your own CI for builds; staged rollouts in both stores
Also
  • Per-platform owners and code review
  • Performance budgets for startup and scroll
  • Detox or Maestro on device farms
AGENTS.md + real projects on STACK IT FAST (opens in a new tab)

Why agents do well here

3/5
  • The shared TypeScript layer remains the agent's home; native modules are isolated behind explicit interfaces it can implement one side at a time.
  • Generated API clients keep the contract honest across the shared layer and any fully native screens.
  • Strong per-platform conventions in Swift and Kotlin mean agent-written native code is reviewable by platform owners.

Avoid at this tier

  • Going fully native because of one slow screen; profile first, then write one module.
  • Sharing UI code between native apps through a home-grown layer.
  • Letting the native and JavaScript sides drift on data models; generate both from the schema.

How it fits together

At scale, consumer apps either keep React Native and add native modules for the hot paths, or move to native apps that share only the API contract. Either way, the shared part is small, generated and typed, and each platform has an owner and its own test command.

Folder layout

apps/mobile/      React Native app, src/, modules/<native-module>/ {ios, android, index.ts}
apps/ios/ apps/android/   only if you go native
packages/api-client/      generated from the API's OpenAPI document

First five decisions

Lock these in before the agent writes the second feature. Each one removes a choice it would otherwise make differently every time.

  1. 01 Profile before writing native code
  2. 02 One interface per native module
  3. 03 Generated clients everywhere
  4. 04 Staged rollouts
  5. 05 Device-farm tests on the flows that make money

When to move on

This is the top tier. From here the work is keeping the boundaries explicit, not changing the stack. The Mobile Scale page lists what stays the same.

Same tier, other profiles