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
| Skill | What They're Looking For |
|---|---|
| Trade-off analysis | WHY you chose X over Y |
| Constraint awareness | Asking about offline, devices, team size |
| Scalability thinking | Works at 10K and 1M users |
| Production experience | Monitoring, error boundaries, crash reporting |
| Communication | Structured answer with diagrams |
The 5-Step Framework
Use this for any system design question:
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.
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
- Save locally with
localIdand statussending - Show in UI immediately
- Queue for delivery when reconnected
- Replace
localIdwith server ID on confirmation
Trade-offs
| Decision | Trade-off |
|---|---|
| WebSocket over polling | Lower latency, higher server memory |
| SQLite for local storage | Structured queries, more setup than MMKV |
| Cursor pagination | Stable under inserts, no random page access |
| Optimistic UI | Feels 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.
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
| Decision | Trade-off |
|---|---|
| FlashList over FlatList | Better scrolling, requires estimatedItemSize tuning |
| Redux for cart only | Centralized logic, extra boilerplate for one slice |
| Stripe SDK | PCI compliant, adds ~3MB and vendor lock-in |
| Map throttling | Smooth 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).
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
| Decision | Trade-off |
|---|---|
| Keychain over AsyncStorage | Hardware security, platform-specific APIs |
| Certificate pinning | MITM protection, cert rotation needed per release |
| No local cache for finances | Secure, always hits network |
| Biometric before transfers | Secure, adds friction |
Common Mistakes
| Mistake | Fix |
|---|---|
| Jumping into code | Spend 5 min on requirements first |
| No clarifying questions | Ask about scale, offline, security |
| Happy path only | Cover offline, timeouts, empty states |
| Ignoring list performance | Mention FlashList and pagination |
| No security for fintech | Cover keychain, pinning, biometrics |
| "I'd use Firebase" | Explain specific services and trade-offs |
| No diagrams | Draw boxes and arrows, always |
Best Practices
- Name specific libraries. "Zustand for UI state, React Query for server state because..." beats "I'd use a state library."
- Show data models early. TypeScript interfaces make the design concrete.
- Separate UI state from server state. Different lifetimes, different caching, different update patterns.
- Address offline first. If it breaks without internet, it's not production-ready.
- Mention monitoring. Sentry for crashes, custom traces for screen load times.
- 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:
- Clarify requirements before drawing
- Define layers with specific library choices
- Deep dive into 2-3 hardest features
- Cover cross-cutting concerns (security, perf, monitoring)
- 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.