📲

In-depth guide

Free React Native Deep Guide for Indian Mobile Developers (2026)

React Native still powers major Indian apps (Razorpay, Walmart, Flipkart Lite). With Expo, building production apps is faster than ever. This guide is the full free path.

Published May 24, 2026 · Updated May 24, 2026

Why React Native is still strong in Indian mobile in 2026

React Native faced strong competition from Flutter post-2020, but it remains a major Indian mobile framework. The 2023-2024 React Native renaissance (New Architecture + Expo SDK 49+) reignited adoption.

Indian companies using React Native in production:

  • Razorpay — merchant app and selected consumer features
  • Walmart Global Tech India — large React Native fleet
  • Flipkart Lite — was React Native (now hybrid)
  • Swiggy — selected modules
  • Tata Cliq, Tata 1mg — some apps
  • Discord, Facebook (Meta IDC) — Indian teams maintain React Native infrastructure
  • Microsoft IDC — Outlook Mobile, Microsoft Teams (parts)
  • Many YC-backed Indian startups — especially those with React engineers

Why React Native still wins (despite Flutter pressure):

  • Reuses your React + TypeScript knowledge (faster onboarding for web devs)
  • JavaScript ecosystem — massive npm package availability
  • Hot reload, large community
  • Easier to find experienced React Native engineers in India than Flutter at senior levels
  • Expo SDK has dramatically improved developer experience
  • New Architecture (Fabric, TurboModules) addressed historical performance concerns
  • React Server Components are being explored for React Native

Where React Native is losing ground:

  • New startup MVPs increasingly choose Flutter
  • UI consistency across platforms is still harder than Flutter
  • Native module bridging can be painful (improving with TurboModules)

Indian React Native salary expectations:

  • Fresher: ₹5-10 LPA at startups, ₹8-15 LPA at funded companies
  • 2-3 years: ₹15-28 LPA
  • 5-7 years: ₹28-55 LPA at product companies
  • Senior+ (8+ years): ₹55 LPA-1 Cr at top product companies
  • Remote contracts: $50-130/hour

The honest framing: React Native is the right choice for Indian engineers who:

  • Already know React well (faster pickup)
  • Target companies maintaining existing React Native apps
  • Want to share code between web and mobile

Flutter is the right choice for Indian engineers who:

  • Are starting fresh in mobile
  • Target post-2022 Indian startup mobile apps
  • Care about pixel-perfect UI consistency across platforms

Both are valid. Don't let internet flame wars decide for you — look at job listings at your target companies.

Expo vs Bare React Native — which to use in 2026

Expo SDK (highly recommended for 95% of cases):

  • Managed workflow with great defaults
  • EAS Build (Expo Application Services) builds your iOS app in cloud without a Mac
  • EAS Update for over-the-air updates (free tier exists)
  • Strong opinionated routing with Expo Router
  • Pre-configured: TypeScript, React Native, popular libraries
  • Used at: Razorpay, Walmart, many YC startups

Bare React Native (when you need it):

  • Direct access to native iOS/Android projects
  • Required for some legacy native modules
  • More control, more complexity
  • Often unnecessary in 2026

Modern Expo (since SDK 50+):

  • Almost no reason to use bare React Native anymore
  • Expo supports any native module via EAS Build's "config plugins"
  • Even Razorpay-style apps with deep native integrations work in Expo

Realistic recommendation:

  • Start with Expo (managed workflow + Expo Router)
  • Use EAS Build for native builds
  • Eject to bare ONLY if you need specific native modifications Expo can't handle (rare in 2026)

Free Expo resources:

14-week React Native + Expo learning roadmap (free)

Prerequisites: Solid React + TypeScript. Use our React Deep Guide.

Week 1 — Setup and first app

  • Install Node.js, then npm i -g expo
  • Create a new Expo project: npx create-expo-app@latest
  • Run on your phone with Expo Go app
  • Or simulators: Android Studio (Windows/Mac/Linux), Xcode (Mac only)
  • Understand file structure (App.tsx, app/ folder for Expo Router)

Week 2 — Core components and styling

  • View, Text, Image, ScrollView, FlatList, SafeAreaView
  • Styling with StyleSheet (similar to CSS but in JS)
  • Flexbox layout (React Native uses Flexbox by default — no display: grid)
  • Touchable components: Pressable, TouchableOpacity
  • Platform-specific code: Platform.OS, Platform.select

Week 3 — Navigation with Expo Router

  • File-based routing (similar to Next.js App Router)
  • Stack navigation (push, pop)
  • Tab navigation
  • Modal screens
  • Dynamic routes ([id].tsx)
  • Linking and deep links

Weeks 4-5 — State management

  • useState, useReducer, useEffect (same as React web)
  • Context API for cross-screen state
  • Zustand (lightweight, popular at Indian product companies)
  • React Query / TanStack Query for server state
  • AsyncStorage for persistent simple data
  • MMKV for performant key-value storage

Week 6 — Forms and validation

  • TextInput (React Native's input component)
  • Controlled inputs with useState
  • React Hook Form (works the same as on web)
  • Validation with zod
  • KeyboardAvoidingView for handling keyboard overlap

Week 7 — API integration

  • Fetch / axios for REST APIs
  • Error handling and loading states
  • Pagination with FlatList onEndReached
  • Pull-to-refresh
  • React Query for caching and optimistic updates

Week 8 — Common native features

  • Camera and image picker (expo-image-picker, expo-camera)
  • Location (expo-location)
  • Push notifications (expo-notifications + Expo Push Notifications service)
  • Biometric auth (expo-local-authentication)
  • File system access (expo-file-system)
  • Sharing content (expo-sharing)

Week 9 — Performance

  • FlatList vs ScrollView (FlatList for long lists — virtualizes rendering)
  • useMemo, useCallback for expensive computations
  • Hermes JavaScript engine (default in 2026)
  • React DevTools Profiler
  • Reanimated 3 for performant animations
  • New Architecture (Fabric, TurboModules) — understand it conceptually

Week 10 — Animations

  • Reanimated 3 (gold standard for React Native animations)
  • Gesture handler for touch interactions
  • Lottie for designer-provided animations
  • Layout animations
  • Native-driven animations (60+ fps even with JS thread busy)

Week 11 — Testing

  • Jest for unit tests
  • React Native Testing Library
  • Detox or Maestro for E2E tests on real devices
  • Snapshot testing
  • TypeScript prevents many runtime errors

Week 12 — EAS Build and CI/CD

  • EAS Build configuration (eas.json)
  • Build profiles (development, preview, production)
  • Building for Android (APK / AAB) and iOS (IPA)
  • EAS Submit for automated app store submission
  • OTA updates with EAS Update (free tier)
  • GitHub Actions integration

Week 13 — App Store / Play Store publishing

  • Apple Developer Program ($99/year)
  • Google Play Console (₹2,000 one-time)
  • App icons, screenshots, store listings, privacy policy
  • Internal / closed / open testing tracks
  • App Store review process (24-48 hours typically)

Week 14 — Production monitoring and growth

  • Sentry for crash reporting (free tier)
  • Analytics: Amplitude, Mixpanel, or Firebase (free tiers)
  • A/B testing with PostHog or Statsig (free tiers)
  • App store optimization (ASO) basics
  • User feedback loops (in-app feedback, reviews)

By end of 14 weeks you'll have 2-3 published React Native apps and be ready for Indian fresher React Native roles.

React Native architecture senior Indian interviewers test

Mid-senior React Native interviews at Razorpay, Walmart Global Tech, Microsoft IDC test architecture deeply:

1. Layered architecture:

  • /app — Expo Router pages
  • /components — reusable UI components
  • /features — feature modules (e.g., /features/auth, /features/payments)
  • /services — API clients, business logic
  • /hooks — custom hooks
  • /utils — pure functions
  • /types — TypeScript types
  • /stores — Zustand stores or contexts

2. State management strategy:

  • Local UI state: useState
  • Form state: React Hook Form
  • Server state: React Query
  • Global client state: Zustand
  • Auth state: separate auth context / Zustand store
  • Persisted state: MMKV via Zustand persist middleware

3. Navigation patterns:

  • Stack for hierarchical flows (Login → Home → Detail)
  • Tabs for primary navigation (Home, Search, Profile)
  • Modals for overlays (settings, dialogs)
  • Drawer for less common (now mostly tabs)
  • Deep linking strategy for marketing / re-engagement

4. Native module strategy:

  • Use existing libraries (react-native-* on npm) when possible
  • Use Expo's official modules (expo-* packages) — well-maintained
  • Write custom TurboModules only when absolutely necessary
  • Check pub.dev / npm regularly — many native concerns now have JS solutions

5. Performance budget:

  • App size budget: <30 MB ideally for Indian audiences (slow downloads on 3G)
  • Cold start: <3 seconds to first interactive
  • 60 FPS scrolling on mid-range Android phones (₹10-15k range — common in India)
  • Memory: <200 MB RAM on average

6. Offline-first design:

  • Indian users frequently have intermittent connectivity
  • Cache aggressively (React Query is great for this)
  • Queue mutations and replay when online
  • Show stale data with refresh indicators

7. Accessibility:

  • accessibilityLabel, accessibilityRole, accessibilityHint
  • VoiceOver / TalkBack testing
  • Hindi / regional language support (use i18next)
  • Dynamic text sizing

8. Security:

  • Don't store secrets in JS (it's bundled)
  • Use Expo SecureStore or react-native-keychain for sensitive tokens
  • Certificate pinning for high-security apps (payments, banking)
  • ProGuard / R8 minification on Android, similar on iOS

Indian interview question pattern: "Walk me through how you'd architect a food delivery app in React Native." Expected: discuss the screens, navigation, state management, API integration strategy, offline support, push notifications, real-time order tracking (WebSockets / polling), payments integration. A confident systematic answer impresses senior interviewers.

Common React Native mistakes Indian developers make

Mistake 1 — Using ScrollView for long lists: ScrollView renders ALL children eagerly. For long lists, use FlatList — it virtualizes rendering. Big performance win on Indian mid-range Android phones.

Mistake 2 — Inline styles instead of StyleSheet: Inline styles create new objects every render, breaking memoization. Use StyleSheet.create() — it caches styles.

Mistake 3 — Not handling Android back button: On Android, hardware back button needs explicit handling for modals, multi-step forms. Use BackHandler API.

Mistake 4 — Forgetting SafeAreaView: Modern phones have notches, dynamic islands. Without SafeAreaView, your content gets cut off.

Mistake 5 — Sharing code between web and React Native: Tempting but risky. Many web libraries don't work in React Native (DOM APIs, browser-specific). Plan separate codebases for web and mobile; share only business logic / API clients via a monorepo.

Mistake 6 — Not testing on real Android devices: Emulators run on your fast computer. Real Indian users have ₹10-15k Android phones. Always test on at least one budget Android device — performance gaps will surprise you.

Mistake 7 — Bloated bundles: Every npm package adds to bundle size. Indian users with slow connections suffer. Use bundle analyzers. Lazy load screens. Use Expo's tree-shaking properly.

Mistake 8 — Ignoring keyboard handling: TextInputs + onscreen keyboard often cause UI overlap. Use KeyboardAvoidingView, KeyboardAwareScrollView, or react-native-keyboard-controller.

Mistake 9 — Reanimated 2 / 3 confusion: Mixing Reanimated 1 patterns with 2/3 leads to silent failures. Use Reanimated 3 patterns exclusively for new code.

Mistake 10 — Not using TypeScript: Plain JavaScript React Native is fragile. Mobile apps have many runtime crashes; TypeScript prevents the most common. Every senior Indian React Native interview expects strong TS.

Mistake 11 — Forgetting OTA update strategy: EAS Update lets you ship JavaScript-only changes without re-submitting to stores. Many Indian apps under-utilize this. Plan your release strategy around OTA + store releases.

Mistake 12 — Not measuring crash-free sessions: Indian apps need to track crash-free session rate. Sentry / Crashlytics. Aim for >99.5%.

Frequently asked questions

React Native or Flutter for Indian career in 2026?▾

If you already know React: React Native (faster pickup, reuse skills). Starting fresh: either works — Flutter has slightly more new startup openings, React Native has more legacy app maintenance roles. Both pay similarly at senior levels.

Expo or bare React Native?▾

Expo for 95% of cases in 2026. Even Razorpay-style complex apps work in Expo now. Use bare React Native only if you need very specific native code that doesn't have an Expo config plugin (rare).

Can I learn React Native without owning a Mac?▾

Yes. For Android development, Windows/Linux work great. For iOS, use EAS Build (Expo's cloud build service) — it builds iOS apps for you without owning a Mac. Many Indian React Native developers publish iOS apps without Macs.

How long to be React Native job-ready?▾

If you know React + TypeScript: 3-4 months. If starting from scratch: 8-12 months including JavaScript, React, then React Native. Most Indian engineering students who know React can transition to React Native fresher jobs in 3-4 months.

Is React Native dying because of Flutter?▾

No. React Native usage at large Indian companies (Razorpay, Walmart, Meta IDC, Microsoft IDC) is stable. New startups split between Flutter and React Native. Both have multi-year futures. Don't believe internet flame wars — both are safe career bets.

Is React Native good for performance-critical apps?▾

Good enough for 95% of apps. The 'New Architecture' (Fabric + TurboModules + JSI) closed historical performance gaps. For 60 FPS animations, use Reanimated 3 (runs animations on the UI thread, not the JS thread). For extreme performance (games, AR), use native iOS / Android.

Can I get a remote React Native job from India?▾

Yes — strong market. US/EU startups regularly hire Indian React Native engineers. Pay: $40-120/hour for mid-senior. Platforms: We Work Remotely, YC Jobs, Toptal, AngelList. Requirements: solid portfolio (3+ apps), good English, async work skills.