Skip to main content
reopt Handbook
reopt Handbook
Expo Enterprise Production

New Architecture

SDK 56 Breaking ChangesNew Architecture Deep DiveReact 19.2 Concurrency Patterns

Native Extensions

Expo UI Nativeexpo-widgets Home Screen WidgetsExpo Modules API v2 Native Extensions

Build and Release

Advanced EAS Build PipelinesEAS Update OTA StrategySecurity, Signing, and Compliance

Operations and Quality

Performance Monitoring and ProfilingTesting StrategyEnterprise Distribution and MDM

Appendix

Verification ReportUpdates
Handbook›Expo Enterprise Production›React 19.2 Concurrency Patterns
한국어English

React 19.2 Concurrency Patterns

Mobile patterns for transitions, Suspense, and route-level loading in Expo SDK 56.

Key takeaways

  • Expo SDK 56 ships React 19.2.3; the production goal is keeping input responsive, isolating slow data, and marking the interactive point after splash work completes.
  • Use useTransition so the input value updates immediately while heavier result rendering is deferred and a pending flag drives UI feedback.
  • Prefer many small Suspense boundaries (tab, sheet, action) over one root spinner so the navigation shell stays interactive.
  • On native, treat Expo Router data loading as route-level cache orchestration, not server components solving mobile loading by themselves.
  • Avoid starting network requests from render, blocking the app behind one root Suspense, or mixing direct React Navigation imports into an SDK 56 Router app.

React 19.2.3 on Mobile

Expo SDK 56 uses React 19.2.3. For mobile production, the important question is not the API list. It is whether rendering keeps input responsive, slow data loading is isolated, and the app marks its interactive point after splash work is truly complete.

useTransition

Use transitions when the input value should update immediately but the heavier result rendering can be deferred.

import { useState, useTransition } from 'react';

export function CustomerSearch({ customers }) {
  const [query, setQuery] = useState('');
  const [filtered, setFiltered] = useState(customers);
  const [pending, startTransition] = useTransition();

  function onChangeText(next: string) {
    setQuery(next);
    startTransition(() => {
      setFiltered(searchCustomers(customers, next));
    });
  }

  return <SearchList query={query} data={filtered} pending={pending} onChangeText={onChangeText} />;
}

Suspense Boundaries

On mobile, one root spinner is usually worse than smaller boundaries. Keep the navigation shell interactive and split fallback UI by tabs, cards, sheets, and critical actions.

LocationRecommended fallback
app rootsplash or skeleton shell
tab contentlist skeleton
modal/sheetcompact loading row
critical actionbutton-level pending state

Expo Router and Data Loading

SDK 56 Expo Router strengthens web streaming SSR and data loading helpers. On native, treat this as route-level cache orchestration rather than expecting server components to solve mobile loading by themselves.

Operating rules:

  • Bootstrap auth, feature flags, and remote config in the root layout and define the markInteractive() point.
  • Wrap route transitions with slower data work in transitions.
  • Keep a backend compatibility window when OTA updates change loader contracts.
  • Give Expo Router web streaming SSR its own performance budget.

Anti-patterns

  • Starting network requests directly from render paths.
  • Blocking the entire app behind one root Suspense boundary.
  • Hiding the splash screen and then waiting again for auth or remote config.
  • Mixing direct React Navigation imports into an SDK 56 Expo Router app.
  • Using startTransition as a substitute for optimistic rollback design.

Verification

  • Measure input latency on slow 3G and lower-end Android devices.
  • Check that Suspense fallback UI preserves accessibility labels and reading order.
  • Use EAS Observe TTI P95 as the rollout gate, not only average values.

Related docs

SDK 56 Breaking Changes

React Native 0.85, Hermes V1, Expo Router separation, platform requirements, and migration checklist.

Verification Report

Official sources, freshness, source conflicts, and code example verification for the Expo SDK 56 handbook.

Next.js Patterns

Enterprise Project Architecture · Use App Router, server boundaries, data fetching, and route ownership consistently.

Graph-Centric Orchestration

Vercel Enterprise AI Platform · Model AI workflows as state, nodes, edges, gates, and recovery paths.

Interaction Design

Design Systems for the AI Era · Tokenize state feedback, microinteractions, and motion behavior.

New Architecture Deep Dive

JSI, Fabric, TurboModules, and production optimization strategy.

Expo UI Native

Declarative SwiftUI, Jetpack Compose, Universal API, and production rollout patterns.

On this page

React 19.2.3 on MobileuseTransitionSuspense BoundariesExpo Router and Data LoadingAnti-patternsVerification