Blog

React Native System Design Interview: Chat, Food Delivery, and Banking App (2026)

By Ahsan Hafeez · 2026-11-10

Senior React Native interviews go beyond hooks and FlatList. Interviewers expect you to design entire mobile systems: offline-first data layers, real-time communication, secure payment flows, and scalable navigation. This guide covers three production-grade system designs the way you'd whiteboard them in an actual interview.

TL;DR

This post covers a reusable 5-step framework for any system design question, three complete app designs (chat, food delivery, banking), and 8 common interview Q&As. Every pattern comes from shipping real production apps.

What Is a Mobile System Design Interview?

Mobile system design focuses on the client side, not servers and load balancers. Interviewers want to see:

  • How data flows from server to screen
  • Offline handling and network failures
  • Caching strategy and duration
  • Navigation at scale (50+ screens)
  • Security on a user-controlled device

Your answers should be 70% client architecture, 30% backend awareness.

Why It Matters for Senior Roles

SkillWhat They're Looking For
Trade-off analysisWHY you chose X over Y
Constraint awarenessAsking about offline, devices, team size
Scalability thinkingWorks at 10K and 1M users
Production experienceMonitoring, error boundaries, crash reporting
CommunicationStructured answer with diagrams

The 5-Step Framework

Use this for any system design question:

5-Step System Design Framework

Step 1: Clarify (2 min) - Ask about users, offline needs, real-time, security, scale.

Step 2: Architecture (3 min) - Draw three layers: Presentation (screens, nav), Domain (state, business rules), Data (API, local DB, cache). Name specific libraries.

Step 3: Deep Dive (15 min) - Pick 2-3 complex features. Show data models, state approach, API contract, caching, error handling.

Step 4: Cross-Cutting (5 min) - Performance, security, monitoring, testing, CI/CD.

Step 5: Trade-offs (3 min) - Explicitly state what you traded off and why.

System Design 1: Chat App

Prompt: "Design a chat application like WhatsApp."

Requirements: 1:1 and group chats, text/image/voice, read receipts, offline queue, search, push notifications.

Chat App Architecture

Data Models

interface Message {
  id: string;
  chatId: string;
  senderId: string;
  content: string;
  type: 'text' | 'image' | 'voice';
  status: 'sending' | 'sent' | 'delivered' | 'read';
  timestamp: number;
  localId: string;
}

WebSocket with Reconnection

class ChatWebSocket {
  private ws: WebSocket | null = null;
  private reconnectAttempts = 0;
  private messageQueue: Message[] = [];

  connect(token: string) {
    this.ws = new WebSocket(`wss://api.example.com/ws?token=${token}`);
    this.ws.onopen = () => {
      this.reconnectAttempts = 0;
      this.flushQueue();
    };
    this.ws.onclose = () => this.scheduleReconnect();
  }

  private scheduleReconnect() {
    if (this.reconnectAttempts >= 10) return;
    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
    this.reconnectAttempts++;
    setTimeout(() => this.connect(this.getStoredToken()), delay);
  }

  send(message: Message) {
    if (this.ws?.readyState === WebSocket.OPEN) {
      this.ws.send(JSON.stringify(message));
    } else {
      this.messageQueue.push(message);
    }
  }
}

Why WebSocket over polling? Polling 100K users every 2s = 50K req/sec. WebSocket gives sub-100ms delivery with a persistent connection. Trade-off: connection management complexity.

Offline Optimistic Send

  1. Save locally with localId and status sending
  2. Show in UI immediately
  3. Queue for delivery when reconnected
  4. Replace localId with server ID on confirmation

Trade-offs

DecisionTrade-off
WebSocket over pollingLower latency, higher server memory
SQLite for local storageStructured queries, more setup than MMKV
Cursor paginationStable under inserts, no random page access
Optimistic UIFeels instant, needs conflict resolution

System Design 2: Food Delivery App

Prompt: "Design a food delivery app like Uber Eats."

Requirements: Restaurant browsing, real-time order tracking with map, cart + payments, push notifications, delivery ETAs.

Food Delivery App Architecture

Restaurant List Performance

import { FlashList } from '@shopify/flash-list';

function RestaurantList({ restaurants }: { restaurants: Restaurant[] }) {
  const renderItem = useCallback(({ item }: { item: Restaurant }) => (
    <RestaurantCard restaurant={item} />
  ), []);

  return (
    <FlashList
      data={restaurants}
      renderItem={renderItem}
      estimatedItemSize={280}
      keyExtractor={(item) => item.id}
    />
  );
}

Why FlashList? Cell recycling like UITableView. For 500 restaurants: 5x fewer component mounts, smooth 60fps on mid-range Android.

Real-Time Order Tracking

function useOrderTracking(orderId: string) {
  const [driverLocation, setDriverLocation] = useState(null);
  const [orderStatus, setOrderStatus] = useState('placed');

  useEffect(() => {
    const ws = new WebSocket(`wss://api.example.com/orders/${orderId}/track`);
    ws.onmessage = (event) => {
      const update = JSON.parse(event.data);
      if (update.type === 'location') setDriverLocation(update.location);
      if (update.type === 'status') setOrderStatus(update.status);
    };
    return () => ws.close();
  }, [orderId]);

  return { driverLocation, orderStatus };
}

Throttle map marker updates to 1/sec to avoid jank from 3/sec GPS pings.

Cart with Redux Toolkit

Redux makes sense here because cart state persists across restarts, multiple screens read/write it, and business rules are complex (single-restaurant enforcement, customization combos). Use redux-persist + MMKV.

Payment via Stripe SDK

Never process card numbers in your code. Stripe's presentPaymentSheet() handles PCI compliance. Your backend creates the payment intent, the SDK handles the UI.

Trade-offs

DecisionTrade-off
FlashList over FlatListBetter scrolling, requires estimatedItemSize tuning
Redux for cart onlyCentralized logic, extra boilerplate for one slice
Stripe SDKPCI compliant, adds ~3MB and vendor lock-in
Map throttlingSmooth animation, 1s position lag

System Design 3: Banking App

Prompt: "Design a mobile banking app."

Requirements: Balance + transaction history, fund transfers, biometric auth, bill payments, strict security (no screenshots, cert pinning, jailbreak detection).

Banking App Architecture

Security Layer (Non-Negotiable)

Secure Token Storage - Use platform Keychain, never AsyncStorage:

import * as Keychain from 'react-native-keychain';

async function storeToken(token: string) {
  await Keychain.setGenericPassword('auth', token, {
    accessControl: Keychain.ACCESS_CONTROL.BIOMETRY_CURRENT_SET,
    accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
    securityLevel: Keychain.SECURITY_LEVEL.SECURE_HARDWARE,
  });
}

Certificate Pinning - Prevents MITM by verifying SSL cert against a known hash bundled in the app.

Jailbreak Detection - Compromised devices can intercept keychain data. Use jail-monkey to detect and warn.

Screenshot Prevention - Block captures on sensitive screens via native module flags.

Biometric Auth Before Transfers

import ReactNativeBiometrics from 'react-native-biometrics';

async function initiateTransfer(transferData: TransferPayload) {
  const biometrics = new ReactNativeBiometrics();
  const { available } = await biometrics.isSensorAvailable();

  if (!available) return authenticateWithPIN();

  const { success } = await biometrics.simplePrompt({
    promptMessage: 'Verify your identity',
  });

  if (!success) return;
  await api.post('/transfers', transferData);
}

Financial Data Caching

Use cacheTime: 0 in React Query for financial data. Balances should never linger in memory after navigation. Every screen load hits the network.

Trade-offs

DecisionTrade-off
Keychain over AsyncStorageHardware security, platform-specific APIs
Certificate pinningMITM protection, cert rotation needed per release
No local cache for financesSecure, always hits network
Biometric before transfersSecure, adds friction

Common Mistakes

MistakeFix
Jumping into codeSpend 5 min on requirements first
No clarifying questionsAsk about scale, offline, security
Happy path onlyCover offline, timeouts, empty states
Ignoring list performanceMention FlashList and pagination
No security for fintechCover keychain, pinning, biometrics
"I'd use Firebase"Explain specific services and trade-offs
No diagramsDraw boxes and arrows, always

Best Practices

  1. Name specific libraries. "Zustand for UI state, React Query for server state because..." beats "I'd use a state library."
  2. Show data models early. TypeScript interfaces make the design concrete.
  3. Separate UI state from server state. Different lifetimes, different caching, different update patterns.
  4. Address offline first. If it breaks without internet, it's not production-ready.
  5. Mention monitoring. Sentry for crashes, custom traces for screen load times.
  6. Know your numbers. "FlatList with 1000 items uses ~800MB on Android" is convincing.

Interview Questions and Answers

Q1: How would you design offline sync?

A: Local DB (WatermelonDB/Realm) as source of truth. Writes go local first, then sync via queue. Last-write-wins for conflicts. Track status per record: synced, pending, conflict. Exponential backoff on reconnect.

Q2: WebSocket vs polling vs SSE?

A: WebSocket for bidirectional (chat). SSE for server-to-client streams (notifications). Polling for low-frequency checks (app version). WebSocket: sub-100ms latency but higher server cost. Polling: simple but wasteful.

Q3: How do you handle token refresh?

A: Refresh token in Keychain. Axios interceptor catches 401, refreshes, retries original request. Queue concurrent requests during refresh. Expired refresh token redirects to login.

Q4: Navigation for 50+ screens?

A: Nested navigators: root stack (auth vs main), bottom tabs for sections, stack per tab. TypeScript for route params. Deep linking config for push notification routing.

Q5: How do you secure sensitive data?

A: Keychain for tokens, certificate pinning, jailbreak detection, screenshot blocking, biometrics before sensitive ops, JS bundle obfuscation. Never log sensitive data.

Q6: Caching strategy for data-heavy apps?

A: Three tiers. Memory (React Query, staleTime per data type). Disk (MMKV/SQLite for offline). Images (FastImage with LRU). Show stale data with background refresh, never a spinner.

Q7: Push notifications with deep linking?

A: Handle foreground and background states. Parse payload for target screen. React Navigation deep linking resolves the route. Cold-start: check initial notification at entry point.

Q8: State management in large apps?

A: Split by ownership. Server state in React Query (caching, refetch, optimistic updates). Global client state (auth, cart) in Zustand/Redux with persistence. Local state in useState. Prevents the "everything in Redux" trap.

Summary

The 5-step framework works for any system design question:

  1. Clarify requirements before drawing
  2. Define layers with specific library choices
  3. Deep dive into 2-3 hardest features
  4. Cover cross-cutting concerns (security, perf, monitoring)
  5. State trade-offs explicitly

Chat, food delivery, and banking cover 90% of interview patterns: real-time communication, offline sync, list performance, secure storage, payments, and location tracking.

FAQ

What detail level for system design interviews?

Breadth-then-depth. 5 min architecture overview, then 15 min deep-diving into 2-3 complex features. The interviewer will ask for more if needed.

Should I write code?

Short TypeScript snippets (interfaces, key functions) help. Full implementations don't. It's about architecture, not syntax.

How is mobile different from backend system design?

Mobile: offline, UI state, navigation, device security, battery constraints. Backend: load balancing, sharding, message queues, horizontal scaling. Senior mobile roles need client depth with backend awareness.

How many apps should I prepare?

5-6 across domains: chat, e-commerce, fintech, social media, maps, healthcare. Patterns overlap heavily. After 3-4 deep preps, you can adapt to anything.

Contact