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:
- Expo official documentation — exceptional
- Expo Router docs
- React Native official docs — also excellent
- William Candillon's "Can it be done in React Native?" YouTube — best free advanced content
- The Net Ninja React Native series
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.