Skip to content
All articles
Blog PostMobile Apps

Building a Cross-Platform Mobile App with React Native

Best practices for building fast, scalable, and maintainable React Native applications.

Muhammad Noman Riaz Apr 4, 2026 9 min read

I built a cross-platform mobile app in React Native as the client for an AI shopping assistant. The backend was FastAPI with PostgreSQL and Redis; the app runs on iOS and Android from one codebase and is in closed beta today. That experience is what this guide is built on. If you're a founder picking a stack, or a developer about to write your first screen, here's the honest version: what React Native is genuinely good at, where native still wins, and the performance work that actually moved the needle for us.

Key Takeaways

  • One React Native codebase took our AI shopping assistant to iOS and Android against a FastAPI backend, sharing services with a WhatsApp channel.
  • Expo's managed workflow gets you to the stores fastest; reach for the bare workflow only when a native module forces your hand.
  • Most real-world jank comes from lists, re-renders, and image handling, not from the framework itself.
  • React Native's New Architecture (Fabric + JSI) removes the old async bridge, which matters most for chatty, interactive screens (React Native, Architecture).

Why choose React Native, and when is native actually better?

React Native lets one team build both platforms from a single JavaScript/TypeScript codebase, which is the entire reason it exists (React Native, Getting Started). For us that meant two platforms, one product team, and no second hire for Swift. The trade is real but smaller than people fear: you write React, you reuse logic, and you only touch native code at the edges.

So when is native the right call? Pick Swift or Kotlin when the app *is* the hard native thing: heavy 3D, real-time camera processing, audio engines, or platform features that ship the day Apple announces them. For a content-and-API app like ours, a shopping assistant talking to a backend, that ceiling never came close. React Native carried the whole product.

React Native shares the same React you already know, so a web team can ship native iOS and Android without learning two new languages first.

One honest caveat from delivery: "write once" is a marketing line, not a guarantee. Roughly the last 10 to 20 percent of polish, the platform-specific gestures, keyboard quirks, and store rules, still costs real time. Budget for it. The savings are large, but they aren't free.

Expo or the bare workflow: which should you start with?

Start with Expo unless you have a concrete reason not to. Expo's managed workflow handles builds, updates, and native configuration for you, which is why it's the recommended way to begin a project (Expo, Documentation). We started managed, stayed managed, and got builds onto both platforms without ever opening Xcode for routine work. The bare workflow is the escape hatch, not the default.

DimensionExpo (managed)Bare workflow
Setup timeMinutes; one commandHours; native tooling to configure
Native modulesLarge prebuilt set + config pluginsAnything, including custom native code
BuildsEAS Build in the cloudYou own Xcode/Gradle pipelines
Over-the-air updatesBuilt in (EAS Update)Manual setup
Best forMost apps, fast iterationDeep native needs or legacy integration
Escape hatchPrebuild to bare anytimeAlready there
How I actually think about Expo (managed) vs the bare workflow.

Here's the part that saved us: you're not locked in. Expo lets you "prebuild" into the bare workflow the moment a library needs custom native code. So the safe move is to begin managed and only eject when a real requirement forces it. Why pay the bare-workflow tax on day one for a need you may never hit?

What does real React Native code look like?

Most screens are a data fetch plus a render, so a small reusable hook removes a lot of boilerplate. Below is the shape of the data-fetching hook I used to talk to our FastAPI backend. It handles loading, errors, and cancellation, which are the three things every screen needs and most tutorials skip.

tsx
import { useEffect, useState } from "react";

type State<T> = { data?: T; loading: boolean; error?: string };

export function useApi<T>(url: string): State<T> {
  const [state, setState] = useState<State<T>>({ loading: true });

  useEffect(() => {
    const controller = new AbortController();
    setState({ loading: true });

    fetch(url, { signal: controller.signal })
      .then((res) => {
        if (!res.ok) throw new Error(`HTTP ${res.status}`);
        return res.json() as Promise<T>;
      })
      .then((data) => setState({ data, loading: false }))
      .catch((err) => {
        if (err.name === "AbortError") return;
        setState({ loading: false, error: String(err) });
      });

    return () => controller.abort();
  }, [url]);

  return state;
}

Notice the AbortController. When a user taps fast between screens, you don't want a stale response landing on the wrong view. Cancelling on unmount is a small detail that quietly prevents a class of flicker bugs. Securing those API calls is its own topic; I cover it in API rate limiting and auth.

Which performance work actually matters?

Performance complaints in React Native almost always trace back to a handful of patterns, not the framework. On our beta builds, the wins came from list virtualization, fewer re-renders, and disciplined image handling. The New Architecture helps too, because Fabric and JSI remove the old async bridge that throttled interactive screens (React Native, Architecture). Here's the checklist I run on every build.

  • Use FlatList (or FlashList) for any long list; never map a big array into a ScrollView.
  • Set keyExtractor and stable keys so rows recycle instead of re-mounting.
  • Memoize list items with React.memo, and wrap callbacks in useCallback to stop needless re-renders.
  • Handle images deliberately: correct sizes, caching, and a fast image library for large galleries.
  • Keep state local; lifting everything to a global store re-renders half the tree on each change.
  • Cut bridge chatter: batch native calls, and adopt the New Architecture (Fabric + JSI) for interactive screens.
  • Profile before optimizing; use the dev tools to find the actual slow render, don't guess.

The single biggest change for us was the list. A product feed re-rendering on every keystroke felt broken; memoized rows in a virtualized list felt instant. None of it was exotic. It was discipline applied in the right three places.

How much can you really share with your web backend?

More than the UI, and that's the underrated win. The app and the backend never shared rendering code, but they shared the contract: types, validation shapes, and API conventions. Our FastAPI service defined the response models, and the React Native client mirrored them in TypeScript, so a backend change surfaced as a type error in the app, not a runtime crash in production.

Treat the API as the shared layer. Keep business rules on the server, where one source of truth serves web and mobile alike, and keep the client thin. If you're designing that server side now, my walkthroughs on Next.js Server Actions and deploying a full-stack app on AWS cover the patterns we used to keep the contract stable across clients.

How do you actually ship to both app stores?

Shipping is a process, not a button, and it's where first-timers lose a week. Expo's build and submit tooling automates most of the mechanical parts, so the real cost is account setup and review, not packaging (Expo, Documentation). Here's the order I follow, start to live, for both platforms from one codebase.

  1. 1Create the developer accounts early: Apple Developer Program and Google Play Console both take time to approve.
  2. 2Set app identifiers, version, and build numbers; get these right before your first upload.
  3. 3Build release binaries with EAS Build (or your own Xcode/Gradle pipeline) for iOS and Android.
  4. 4Prepare store listings: screenshots, descriptions, privacy details, and a clear permissions rationale.
  5. 5Submit through TestFlight and Google Play internal testing before going public.
  6. 6Use over-the-air updates for JS-only fixes, but ship a new binary for native changes.

One thing nobody warns you about: review timelines and privacy questionnaires. Apple in particular will ask why you need each permission, so write that down before you submit. The code was the easy part. The store paperwork is what surprises people.

Where mobile dev time actually went on our project
Feature screens + logic~45%
Performance + list tuning~20%
Platform polish + edge cases~20%
Store submission + review~15%

Illustrative allocation from one delivery, not survey data: most effort lived outside core feature code.

That split surprises people. Less than half the time was "building features." The rest was the work that turns a working app into a shippable one. Plan for it, and the timeline stops feeling like a series of surprises.

Frequently asked questions

Is React Native good enough for a production app? Yes. We built a real product on it against a FastAPI backend, running on both iOS and Android from one codebase. For API-driven apps it's well past "good enough." The framework wasn't the limit; our own list and state discipline was what determined how smooth it felt.

Should I use Expo or go bare? Start with Expo. Its managed workflow is the recommended starting point and handles builds, updates, and configuration for you (Expo, Documentation). Because you can prebuild into the bare workflow at any time, there's no penalty for starting managed. Only eject when a specific native module genuinely requires custom code you can't get otherwise.

What is the New Architecture and do I need it? It's React Native's rebuilt core, Fabric and JSI, that replaces the old asynchronous bridge with direct calls between JavaScript and native (React Native, Architecture). You don't have to think about it constantly, but it noticeably helps interactive, chatty screens. New projects increasingly get it by default, so I'd build on it rather than against it.

The bottom line

A cross-platform mobile app in React Native is a sound default for most products, and I'd choose it again. We built a real AI shopping assistant for both platforms from one codebase and never needed a separate native team. Start with Expo, keep your business logic on the server, and spend your performance budget on lists, re-renders, and images. That's where the smoothness is won.

If you're weighing this stack for your own build, the practical questions are usually about the backend contract and deployment, not the UI. I write about those next in Next.js Server Actions and deploying full-stack on AWS. Read those, then map your own app's native needs, and the Expo-versus-bare decision answers itself.

Sources

  1. 1React Native, Getting Started - retrieved 2026-06-23
  2. 2Expo, Documentation - retrieved 2026-06-23
  3. 3React Native, Architecture - retrieved 2026-06-23
React NativeExpoMobile AppsCross-Platform

Get the next post

New writing on AI engineering, RAG, and shipping real products - straight to your inbox, no noise.

Ready to build something useful?

Whether you need a freelance build, a full-time hire, or a short intro call, pick the path that fits and I will respond within 24 hours.