Building for iOS and Android separately is expensive and slow. Cross-platform development done right gives you native performance with shared code. We build with Flutter or React Native depending on what matters for your app: performance, team skills, ecosystem. Both approaches scale. Both ship real apps.
Cross-platform mobile development means writing code once that runs on iOS and Android. You share 60-80% of your codebase. You maintain one release cycle. You reduce costs and ship faster. We use Flutter (Dart, native performance) or React Native (JavaScript, large ecosystem). We choose based on your app's needs and your team's skills.
Evaluate Flutter vs React Native for your app.
Design shared architecture with minimal platform-specific code.
Build iteratively for both platforms simultaneously.
Deploy to both app stores on the same day.
The cross-platform question is not "Flutter or React Native" — it is whether shared-code development is the right model for your product at all. The answer depends on your target platforms, your performance requirements, your team composition, and whether the 40–46% Year 1 cost saving survives contact with your actual feature roadmap. This section gives you the data to make that call correctly, not the marketing narrative.
Cross-platform mobile development in 2024–2025 has two production-grade options for native-rendering apps (Flutter and React Native) and two viable options for web-tech hybrid apps (Expo as a React Native platform, and Capacitor for web-to-native wrapping). Understanding the architectural difference between these categories is more important than benchmarking them against each other.
| Factor | Flutter 3.24 | React Native 0.75 (New Arch) | Expo SDK 51 | Capacitor 6 |
|---|---|---|---|---|
| Rendering model | Custom renderer (Impeller); every pixel drawn by Flutter | Maps to actual native views via JSI + Fabric | Same as React Native (RN platform) | WebView rendering; HTML/CSS/JS in a native shell |
| Language | Dart 3.5 (null-safe, records, patterns) | JavaScript / TypeScript (~85% TS adoption) | TypeScript (Expo Router v3 enforces structure) | Any web framework (React, Vue, Angular, Vanilla) |
| iOS cold start (iPhone 14) | 560–750ms | 680–950ms | 800–1,100ms (managed workflow overhead) | 900–1,400ms (WebView init) |
| Android cold start (Pixel 7) | 750–1,050ms | 900–1,300ms | 1,100–1,500ms | 1,200–1,800ms |
| Native API access | Via platform channels; pub.dev packages cover ~80% of common APIs | Via TurboModules (JSI); npm ecosystem covers ~85% of common APIs | Via Expo SDK modules; covers top ~70%; EAS for native builds | Via Capacitor plugins; covers standard device APIs |
| OTA updates (no App Store review) | Via Shorebird (Dart VM bytecode patching); $20/month | Via EAS Update (Expo); free tier + $29/month Pro | EAS Update built-in; rollback supported (2024) | Live Update via Appflow / Ionic Deploy |
| Community size (GitHub stars) | ~165K stars; growing ~35K/year | ~118K stars; growing ~20K/year | ~35K stars (Expo repo); backed by RN community | ~12K stars; mature but slower growth |
| Hire availability (LinkedIn open roles, Jan 2025) | ~6,200 global Flutter roles | ~8,400 global React Native roles | Included in React Native pool | ~2,000–3,000 global roles |
| Platform support beyond mobile | iOS, Android, Web, macOS, Windows, Linux (stable) | iOS, Android (Web via React Native Web, limited) | iOS, Android, Web (Expo Router universal) | iOS, Android, Web, Electron (desktop via web) |
| Thoughtworks Tech Radar 2024 | Adopt (highest tier) | Trial | N/A (not separately listed) | Assess |
Flutter's Stack Overflow 2024 usage (9.2%) now exceeds React Native's (8.3%) among developers who do mobile — a reversal from 2022. JetBrains 2024 found Flutter at 12% of surveyed developers, highest cross-platform framework share. The job market still skews native 3–4× (22,000 Swift roles and 19,000 Kotlin roles vs. 8,400 RN and 6,200 Flutter), confirming that cross-platform has not displaced native — it has created an additional hiring pool. Approximately 8% of top-500 grossing iOS apps are built with Flutter or React Native; among the top 50, 0% use cross-platform for primary UI (Sensor Tower 2023) — the premium consumer category still votes native with its wallet. DeepLearnHQ take: when a client arrives with a strong React or web team, React Native plus Expo is the right recommendation; when they arrive with no existing mobile expertise, we recommend Flutter — the stronger performance profile and Dart type system produce fewer production incidents on first-time mobile teams.
Flutter apps in production (2024). Google Pay (Google), eBay Motors (eBay), Xianyu (Alibaba's peer-to-peer marketplace, 50M+ users), BMW Connected (BMW), and Nubank (Latin America's largest neobank, partial). These are not MVPs — they are high-traffic, regulated, at-scale applications that have validated Flutter's production readiness in demanding categories.
React Native apps in production (2024). Shopify's merchant app, Discord (partial), Microsoft Teams (partial), Wix, and Meta's Facebook app (partial — the original Airbnb and Facebook RN experiments predate the New Architecture, which substantially changes the reliability profile). The "Instagram ditched React Native" narrative from 2018 is often misquoted — the issues were specific to their legacy Objective-C plus RN hybrid; modern RN New Architecture is architecturally different from the app they abandoned.
Performance benchmarks for cross-platform frameworks must be understood in context: the absolute numbers matter less than how they translate into user-visible outcomes at your target hardware tier. A 200ms cold start difference is imperceptible to users; a 15-percentage-point difference in 60fps scroll consistency on mid-range Android hardware produces visible jank that users do notice.
| Framework | iOS Cold Start (iPhone 14) | Android Cold Start (Pixel 7) | Android Cold Start (Mid-range, SD 6 Gen 1) |
|---|---|---|---|
| Native Swift/SwiftUI | 380–550ms | — | — |
| Native Kotlin/Compose | — | 480–680ms | 700–1,000ms |
| Flutter 3.16+ (Impeller) | 560–750ms | 750–1,050ms | 1,100–1,600ms |
| React Native 0.74 (New Arch + Hermes) | 680–950ms | 900–1,300ms | 1,400–2,000ms |
| Expo (managed workflow) | 800–1,100ms | 1,100–1,500ms | 1,600–2,200ms |
Flutter's Impeller renderer (default since Flutter 3.10 on iOS, Flutter 3.16 on Android) made the greatest single performance improvement of any cross-platform framework in 2023–2024, eliminating the shader compilation jank that had been Flutter 2.x's most-cited production complaint. The New Architecture (JSI + Fabric + TurboModules) similarly improved React Native's performance profile — bridged RN 0.6x would drop to 50–60% 60fps scroll consistency on complex lists; New Architecture RN holds 85–91% on flagship Android hardware. Neither framework has yet closed the cold start gap with native on mid-range Android hardware, which is the benchmark that matters in India, Southeast Asia, and Latin America. DeepLearnHQ take: the performance conversation that clients need to have is not "which framework is faster in a benchmark" but "what is the 60fps consistency floor on our P90 device" — we build that device profile before selecting a framework on every engagement.
The feature that native frameworks cannot match is over-the-air updates to JavaScript or Dart logic without App Store review. For React Native apps using Expo, EAS Update deploys changes in seconds with incremental bundles typically 50–200KB. The 2024 EAS Update rollback feature enables instant revert without publishing a new build. For Flutter, Shorebird.dev (founded by former Google Flutter engineers) provides OTA updates by patching the Dart VM at the bytecode level — extending this capability to Flutter at $20/month for the Starter plan.
Both solutions operate within App Store guidelines — updates cannot change the app's fundamental purpose or add new capabilities requiring review. Bug fixes, content changes, feature flags, A/B test variants, and UI copy changes are all valid OTA targets. For consumer apps with weekly release cadences or apps requiring rapid response to production incidents, this capability alone can justify the cross-platform choice regardless of all other factors. No native app can push a critical bug fix to all users in under 5 minutes without going through App Store review.
Cross-platform is not universally inferior to native. There are specific categories where it is the rational first choice — and specific categories where it is a false economy that produces higher total cost than native despite lower sticker price. Mapping your product to the correct quadrant is the most important cross-platform decision you will make.
Native is required (no debate) when the app needs any of the following: custom camera pipeline or media processing; ARKit/ARCore advanced features (Scene Semantics, Geospatial, LiDAR); hardware security operations (Secure Enclave, Play Integrity API); Apple Intelligence APIs (App Intents, Image Playground, Writing Tools customization); visionOS roadmap; Android Enterprise Device Policy Controller or device owner mode; OS-level system extensions (widgets, App Clips, Instant Apps).
Cross-platform is optimal when:
B2B and enterprise utility apps. CRUD-heavy apps with standard UI patterns (forms, lists, dashboards), internal tooling, field service apps. No cutting-edge hardware required. Standard platform APIs. Two-platform coverage needed. Flutter or React Native delivers at 50–60% of native two-platform cost — and the standard UI patterns mean users never perceive a quality difference.
Content and media apps. News, media streaming (video handled via native video_player or react-native-video plugins), podcasts, documentation viewers. Platform-specific rendering does not add value over a cross-platform component for standard media display.
MVP and market validation. Getting a functional, polished app in front of users in 8–12 weeks on both platforms simultaneously. Iteration speed trumps performance purity in pre-PMF phase. The per-platform parity that cross-platform provides (iOS and Android features shipping simultaneously) is often more valuable than the performance ceiling of native during validation.
E-commerce with standard checkout flows. Product lists, detail pages, cart, checkout integrated with Stripe, Braintree, or platform payment SDKs. Apple Pay and Google Pay work via plugin on both platforms. No hardware sensor requirements.
Cross-platform is a false economy when:
Single-platform apps. If you only need iOS or only need Android, cross-platform provides zero code-sharing benefit. The cost of learning Dart or React Native plus platform channel overhead exceeds native development costs — this is a common mistake teams make when choosing cross-platform "to avoid Swift."
Highly animated consumer apps. Custom gesture recognizers, physics-based animations, and proprietary transition styles require native to achieve the quality bar set by top-grossing apps. The 5% of UI where platform-specific animation curves and haptics create a perception of quality is exactly where cross-platform falls short.
Apps that will accumulate native modules. A team that starts with Flutter for simplicity and adds 5+ native modules (camera, NFC, health, security, ML) over 2 years has effectively built a hybrid app with Dart glue code. The maintenance cost typically exceeds what a native app would have cost by year 3.
For enterprises already invested in native Android development, Kotlin Multiplatform (KMP, stable since November 2023) offers a third path: share business logic between Android (Kotlin/Compose) and iOS (KMP + SwiftUI), while maintaining native presentation layers. This is not Flutter or React Native — it is native UI on both platforms with shared Kotlin business logic. Companies using KMP in production include Netflix (mobile SDK), VMware (Workspace ONE), Philips (HealthSuite), and Cash App (Square). The KMP model retains native UI fidelity while achieving 40–60% code sharing in the domain and data layers — the architecture that makes the most sense for teams with existing native investment who want incremental, not wholesale, platform change.
The cross-platform cost saving is real — and often overstated. The 40–50% Year 1 saving is front-loaded. By Year 3, the delta between cross-platform and native narrows significantly as native module requirements accumulate and framework migration events (React Native New Architecture, Flutter major versions) require refactoring investment. This model is the honest version of the tradeoff.
| Cost Category | Native (2 iOS + 2 Android) | Flutter (2 engineers) | React Native / Expo (2 engineers) |
|---|---|---|---|
| Year 1 development | $640K–$880K | $320K–$440K | $320K–$440K |
| Year 1 QA (25% of dev) | $160K–$220K | $80K–$110K | $80K–$110K |
| Year 2 maintenance | $480K–$640K | $240K–$320K | $260K–$360K |
| Year 3 maintenance | $480K–$640K | $260K–$360K | $280K–$400K |
| Native module development (Year 2+) | $0 | $40K–$120K | $60K–$160K |
| 3-year total | $1.76M–$2.38M | $940K–$1.35M | $1.0M–$1.47M |
| Savings vs native | Baseline | ~46% lower | ~40% lower |
Assumptions: US market engineering rates at $120K–$160K per engineer per year fully loaded. Native team equals 2 iOS plus 2 Android engineers. Cross-platform team equals 2 engineers. QA included at 25% of dev cost. Native module development budgeted at $40K–$160K depending on complexity. The 3-year savings are real but not dramatic — the actual ROI of cross-platform is not just cost, it is synchronized platform parity (iOS and Android features ship simultaneously with two engineers instead of four) and smaller team coordination overhead. A Slalom Consulting internal benchmark (2023) found 45% cost reduction vs parallel native teams on a mid-complexity enterprise app — front-loaded in Year 1, narrowing to 25–30% lower in Years 2–3 as native module growth accumulated. DeepLearnHQ take: the clients who get the most value from cross-platform are the ones who constrain their native API usage budget upfront — every native module you commit to in Year 1 is a Dart or JS maintenance item forever, and teams that do not track that debt always end up surprised by Year 3 maintenance costs.
Selecting a cross-platform development partner requires different due diligence than selecting a native shop. The risk profile is different: cross-platform agencies without native competency will block on you when platform-channel work is required, and cross-platform agencies that have not shipped production apps at scale often underestimate the App Store policy and OTA update compliance complexity.
Framework version currency. Any Flutter agency should be on Flutter 3.16+ with Impeller enabled and demonstrably migrated away from the old skia renderer. Any React Native agency should be on the New Architecture (RN 0.73+ minimum) with Hermes enabled. These are table-stakes that disqualify agencies maintaining legacy codebases — the New Architecture migration required substantial refactoring for many teams in 2023–2024, and agencies that have not completed it are carrying technical debt that will land in your project.
Expo expertise for React Native. Agencies that still avoid Expo in 2024 are working harder than necessary. EAS Build, EAS Update, and Expo Router are not optional extras — they are the production-standard React Native toolchain. A React Native agency that cannot discuss EAS Update rollback strategy is not operating at the current standard.
Native module authoring competency. Ask specifically: "If a feature we need has no pub.dev or npm package, how do you handle it?" The answer must include Swift and Kotlin implementation capability. Cross-platform agencies without native competency will block your roadmap at exactly the wrong time — and the features that require native modules are typically the ones that matter most to your product differentiation.
OTA update strategy and App Store compliance. Cross-platform apps that use OTA updates can trigger Apple reviewer scrutiny if the update capability is perceived as changing app functionality or bypassing review. An agency that has navigated an App Store review with an active OTA update pipeline has operational knowledge that matters. Ask them how they handle the boundary between "feature changes requiring review" and "bug fixes eligible for OTA."
Performance profiling tooling. Flutter DevTools (CPU profiler, widget rebuild tracker, memory analyzer) and React Native's Flipper, Reactotron, and the New Architecture's built-in performance debugging tools are the debugging platforms. Agencies that cannot articulate their performance debugging workflow are guessing in production. Ask for a specific example of a performance regression they diagnosed and resolved on a shipped app.
Android fragmentation testing strategy. Cross-platform does not eliminate Android fragmentation costs — it reduces code authoring costs while leaving testing costs intact. Any cross-platform agency must have a device farm strategy (Firebase Test Lab, BrowserStack, or owned devices) covering at least Samsung One UI, Xiaomi MIUI, and 2+ budget hardware tiers. Agencies whose test matrix is exclusively emulators have not shipped to real Android users at scale.
React Native. iOS and Android simultaneously. 2M+ bookings monthly.
Flutter. High-performance graphics. 500K+ active users.
For 80% of apps, yes. If your app does heavy graphics or intense computation, pure native might win. For most business apps, cross-platform is indistinguishable.
Flutter is faster and more opinionated. React Native is more flexible and JavaScript-based. For performance-critical apps, Flutter usually wins.
Yes. If cross-platform isn't meeting your needs, we can rebuild specific features in native. It's not wasted effort—you've validated the product.
We write platform-specific code where needed (camera, notifications, payment). We keep it small and localized.
Tell us about your problem. We'll give you an honest read on scope, approach, and whether we're the right team.