React Native vs Flutter in 2022

Every mobile stack debate is two parts engineering and one part religion. In 2022, the practical choice for most Indian startups still narrowed to React Native or Flutter. Native iOS/Swift and Android/Kotlin were correct and slow for small teams. Kotlin Multiplatform was promising and thin on hiring. Xamarin was a ghost.

I have shipped with both RN and Flutter. Neither is free. Here is how they compared when Hermes matured, Material 3 landed, and everyone pretended they would rewrite the app “after PMF.”

The Real Question: What Are You Optimizing?

• Time to hire in India: React Native usually wins on JS/React familiarity.
• UI consistency across platforms: Flutter wins if you accept its widget religion.
• Integration with existing web team: RN if your web team is React-heavy.
• Animation-heavy custom UI: Flutter’s compositor model is pleasant.
• Brownfield native modules: RN’s bridge ecosystem is older, messier, more examples.

Pick constraints, not logos.

React Native in 2022: Not the Old Bridge Monolith

The New Architecture (Fabric renderer, TurboModules, JSI) was rolling out. Hermes became the default JavaScript engine on many templates. Hermes improved startup time and memory versus JSC on mid-range Android devices, which is most of India.

RN still renders native components. Your React tree maps to UIView and Android views. That means platform quirks leak through: spacing, keyboards, navigation transitions, accessibility edge cases.

Strengths:

• Massive JS talent pool
• Share logic and some UI patterns with React web
• Mature libraries for navigation, forms, analytics
• Easier incremental adoption in apps with existing native code

Weaknesses:

• Performance cliffs when bridge chatter returns on bad lists
• Dependency hell when native modules disagree on RN version
• UI consistency requires discipline; platforms look “almost the same”

If your team already thinks in hooks and Redux, RN is the path of least political resistance.

Flutter in 2022: Skia All the Way Down

Flutter draws its own pixels via Skia (and Impeller coming for iOS). No native widget mapping for the core UI. One rendering pipeline, one layout model, one set of animations.

That is liberating until you need a platform-specific behavior that fights the framework.

Strengths:

• Predictable UI across iOS and Android
• Hot reload culture is excellent for designer-engineer loops
• Strong performance on animations and custom painters
• Single language (Dart) end to end, fewer “who owns the native module” disputes

Weaknesses:

• Smaller hiring pool than JS in most Indian cities
• APK/IPA size baseline heavier than minimal RN apps
• Platform channel glue for obscure SDKs
• Dart is fine; convincing seniors to learn it is a sales job

Rendering Pipeline: Where the Philosophies Diverge

flowchart TB
    subgraph rn["React Native"]
        RNJS["JavaScript (Hermes)"] --> JSI["JSI / TurboModules"]
        JSI --> Fabric["Fabric renderer"]
        Fabric --> NativeW["Native views (UIKit / Android)"]
    end
    subgraph fl["Flutter"]
        DartUI["Dart framework"] --> Engine["Flutter engine"]
        Engine --> Skia["Skia compositor"]
        Skia --> GPU["GPU surface"]
    end

RN: JavaScript orchestrates native widgets. Flutter: Dart orchestrates pixels. The RN diagram still has more moving parts at the UI boundary. That matters for debugging flicker at 3 AM.

Hermes Changed the RN Calculus

Before Hermes, RN startup on budget Android was a punchline. Hermes bytecode, ahead-of-time compilation, and tighter memory made RN credible for consumer apps in India where devices skew mid-range.

It did not erase Flutter’s advantages. It removed one historical RN veto from architecture reviews.

Hiring in India: The Uncomfortable Truth

Job boards lie. Real hiring data in 2022 India:

• React Native: Easier to find candidates who have touched React. Depth varies wildly. Many “2 years RN” resumes are mostly web with one Expo toy app.
• Flutter: Harder to fill senior slots outside Bangalore/Hyderabad/Pune bubbles. Strong Flutter devs exist; they cost more attention to recruit.

For startups, time-to-hire beats benchmark FPS. A good RN team ships before a perfect Flutter team is assembled.

For design-heavy products with custom UI, paying the Flutter recruiting tax can still be correct.

Ecosystem and Third-Party SDK Pain

Both ecosystems suffer when a payment gateway or KYC SDK ships a half-maintained plugin. RN has more wrappers because it is older. Flutter plugins are often cleaner when they exist.

Evaluate your mandatory SDK list before choosing. If your vertical needs a SDK with only a RN bridge, the debate ends.

Developer Experience

RN: JavaScript tooling, TypeScript adoption high, Metro bundler quirks, flipper debugging when it works.

Flutter: flutter doctor is honest about your broken Xcode. DevTools solid. Build times creep on large apps.

Neither is Xcode Storyboards hell. Both beat that.

Performance: Stop Quoting Hello World

List scrolling, image caching, and navigation stacks dominate perceived performance. Both frameworks can stutter:

• RN: fix list virtualization, memoization, native driver for animations
• Flutter: watch build method rebuild storms, profile with DevTools

Microbenchmarks are for conference talks. Profile your actual screens.

Opinionated Recommendation for 2022

Choose React Native if:

• Your team is mostly web React engineers
• You need gradual native integration
• Hiring speed in India is critical
• Your UI is standard forms + lists + modals

Choose Flutter if:

• UI consistency and motion design are core product value
• You can afford Dart onboarding
• You want fewer platform visual leaks
• Your app is greenfield without legacy native

Choose native if:

• You have budget for two platform teams and complex platform APIs dominate

What I Would Not Do

Rewrite a shipping RN app to Flutter for “performance” without profiling.

Pick Flutter because Twitter said Google killed RN. RN was very much alive.

Ignore accessibility. Both frameworks require work; RN inherits some platform behavior, Flutter requires you to wire semantics deliberately.

Closing

React Native vs Flutter in 2022 was not a knockout. Hermes narrowed RN’s weakness. Flutter matured tooling. The winner is the stack your team can ship and maintain for three years.

Founders want a verdict. The verdict is constraints. Hire for what you choose. Profile what you ship. Ignore holy wars from people who have not released a Play Store update in six months.