Mobile Apps with React Native & Flutter
A survey of how web developers build mobile apps without starting over — React Native, Flutter, and when neither is the right call.
Mobile Apps with React Native & Flutter
The player loads from youtube-nocookie.com when you press play. Nothing reaches YouTube before that.
Not started
What you'll learn
- Native mobile development means writing and maintaining two separate codebases — Swift/Kotlin for iOS, Kotlin/Java for Android — which is why cross-platform frameworks exist at all.
- React Native renders real native UI components through a bridge, so a `<View>` in your JavaScript becomes an actual `UIView` or `android.view.View` on the device, not a webpage pretending to be an app.
- Flutter doesn't use native components at all — it draws every pixel itself with its own rendering engine, which buys pixel-perfect consistency across platforms at the cost of not automatically picking up OS-level UI changes.
- Choosing a cross-platform tool is mostly about what team and skills you already have: React Native leverages existing JavaScript and React knowledge, Flutter requires learning Dart and a different component model from scratch.
- None of this is free — truly native-feeling performance, deep platform-specific integrations, and tiny app size still sometimes push teams back toward fully native development for one platform or the other.
The problem: two phones, two codebases
Everything in this roadmap up to this point has lived in one place: the browser. A browser is a single runtime that Chrome, Safari, and Firefox all mostly agree on, and your HTML, CSS, and JavaScript run the same way regardless of which one opens the page. Mobile phones don’t offer you that deal.
iOS and Android are two genuinely different operating systems with two different official toolchains. An iOS app is traditionally written in Swift (or older Objective-C) using Apple’s UIKit or SwiftUI. An Android app is written in Kotlin (or older Java) using Android’s own view system. There’s no shared language, no shared UI framework, and no shared App Store — Apple’s review process and Google Play’s are separate pipelines with separate rules. If you want your app on both platforms the “native” way, you’re maintaining two codebases, written in two languages, by people with two different sets of platform expertise, that need to somehow ship the same features at the same time.
For a small team, or a web developer who already knows JavaScript and doesn’t want to learn Swift and Kotlin just to ship one app, that’s a lot of overhead before you’ve written a single feature. That’s the gap cross-platform mobile frameworks exist to close: write the app once, run it on both platforms.
React Native: real native UI, driven by JavaScript
React Native’s pitch is specific: it’s not “a webpage in an app” — that’s a different, older idea (think early Cordova/PhoneGap apps wrapping a WebView), and it’s slow and feels wrong because it is, literally, a browser tab pretending to be an app. React Native does something different. Your JavaScript, written with the same component model as React on the web — state, props, hooks, the works — doesn’t render HTML. It renders a tree of native UI elements. A <View> becomes a real UIView on iOS and a real android.view.View on Android. A <Text> becomes a real native text label. The JavaScript thread describes what the UI should look like, and a bridge (or, in the newer architecture, a more direct JSI connection) hands that description over to the native side, which builds actual platform widgets.
The payoff is that the app behaves like a native app — native scrolling physics, native text rendering, native accessibility support — because under the hood, it is one. The cost is that you’re coordinating two different runtimes (JavaScript and native) and the bridge between them is a real engineering surface with its own performance characteristics and its own category of bugs.
For a web developer, the draw is obvious: if you already know React, you already know React Native’s component model, its state management patterns, and often a meaningful chunk of your actual business logic — validation rules, API clients, data transformations — can be shared almost as-is between your web app and your mobile app.
Flutter: skip native widgets, draw everything yourself
Flutter takes a different bet. Instead of translating your code into native widgets, Flutter doesn’t use native widgets at all. It ships its own rendering engine (built on Skia, and more recently Impeller) and draws every button, every scrollbar, every animation itself, pixel by pixel, directly onto a canvas that sits on top of the OS. Your Flutter app is written in Dart, a language purpose-built by Google for this job, with a declarative widget model that will feel conceptually familiar if you know React — everything is a widget, widgets compose, and the UI is a function of state — but the syntax and tooling are their own thing to learn.
The upside of owning your own rendering is consistency: a Flutter app looks and behaves pixel-for-pixel identically on iOS and Android, because it isn’t relying on two different platforms’ native widget kits to agree with each other — it’s not relying on them at all. The downside is the flip side of the same coin: when Apple or Google changes something about how a native control looks or feels, a React Native app picks that up for free, because it’s genuinely using the native control. A Flutter app doesn’t — it picks it up only when the Flutter framework itself gets updated to match.
How to actually choose
In practice, the decision usually isn’t “which framework is objectively better” — both are used in production by large companies, both can ship fast, polished apps. It’s “what does my team already know, and what does this specific app need.” A team full of React and TypeScript developers who want to share code and context with an existing web app has a strong gravitational pull toward React Native. A team starting fresh, or one that prioritizes one visual experience across every device over native look-and-feel, may prefer Flutter’s self-contained rendering and single language.
It’s also worth knowing both frameworks exist alongside other approaches you’ll run into: Kotlin Multiplatform (share logic, keep native UI on each platform), and fully native development, which some teams still choose when an app needs the absolute ceiling of performance, deep OS integration (think camera pipelines, background audio, or hardware-specific APIs), or the smallest possible binary size. Cross-platform frameworks close most of the gap between “native” and “write once” — they don’t erase it entirely, and knowing that tradeoff exists is more valuable here than memorizing either framework’s API.
Check yourself
Why do cross-platform mobile frameworks exist in the first place?
Building a mobile app natively means writing it twice — once in Swift or Objective-C for iOS, once in Kotlin or Java for Android — with two codebases to keep in sync and two teams' worth of platform expertise to maintain, so cross-platform tools exist to let one codebase target both.
What's the key architectural difference between how React Native and Flutter put pixels on the screen?
React Native's JavaScript describes a UI tree that gets translated, through a bridge, into real native platform widgets, while Flutter skips native widgets entirely and uses its own engine to draw every pixel directly onto a canvas.
If a team already has a React web app and wants to go mobile, why would React Native often be the more obvious starting point than Flutter?
React Native reuses the team's existing JavaScript, React component model, and often a meaningful slice of business logic, while Flutter requires learning a new language (Dart) and a different way of structuring UI from scratch.
What's one real tradeoff Flutter accepts in exchange for its pixel-perfect rendering consistency?
Because Flutter paints its own widgets instead of using the OS's native ones, it doesn't automatically inherit platform UI updates — when iOS or Android changes a native control's look or behavior, Flutter's version only follows once the framework itself is updated to match.
Go deeper
Notes
Notes are saved to your account.
Everything else on this page works without one — progress and bookmarks keep themselves in this browser and come with you when you sign in. Notes are the one thing worth not trusting to a browser you might clear.
Your notes could not be loaded.