Google's cross-platform toolkit — what one codebase actually buys you, and where it stops being the right answer.
Flutter is Google's toolkit for building Android, iOS, web and desktop apps from a single codebase written in Dart. Unlike approaches that wrap a web view or translate to native components, Flutter draws its own widgets onto a canvas, which is why the same build looks and behaves identically on both platforms.
The commercial argument for Flutter is simple: one team, one codebase, two platforms. In practice the saving is real but smaller than the headline — roughly a third to a half rather than half of everything — because platform-specific work, store submission and testing do not halve. What does improve markedly is that the two platforms stop drifting apart feature by feature.
The UI is composed of widgets, declared in code rather than laid out in a designer. State flows down, events flow up.
Provider, Riverpod, Bloc and others. The choice matters more than it looks — it shapes how the whole app is structured.
Where native capability is needed — a specific SDK, a hardware feature — Flutter calls into platform code through a channel.
SQLite, Hive or Isar for local persistence, with a sync layer where the app must work without signal.
One codebase produces both store builds, through CI. Store review and signing remain platform-specific work.
A business needs an internal app for field staff on both Android and iOS: forms, a list, a camera capture, offline storage and sync.
Built natively, this is two codebases — Kotlin and Swift — two teams or one team context-switching, two sets of tests and two release cycles. The business logic, which is most of the work, is written twice and must be kept identical. Divergence between the two platforms is the normal state, and reconciling it is a permanent tax.
Built in Flutter, the logic and interface are written once. Platform-specific work remains for things like push notification setup, permissions and store release, but it is a fraction of the whole. The saving is real and is commonly in the range of thirty to forty percent for this kind of app — but it is largest for exactly this profile. For an app whose value is deep platform integration, heavy use of new OS features, or demanding graphics, the shared portion shrinks and the argument weakens accordingly.
| Term | What it means |
|---|---|
| Widget | The basic building block of a Flutter interface. Everything visible is a widget. |
| Dart | The language Flutter is written in, compiled ahead of time to native code for release builds. |
| Hot reload | Applying code changes to a running app without restarting it, which is where much of the speed comes from. |
| Platform channel | The bridge to native code when a feature has no Flutter package. |
| Skia / Impeller | The rendering engines Flutter draws with, which is why it looks identical across platforms. |
Shared code is most of the UI and logic. Testing, store work and platform-specific features still cost on both sides.
Retrofitting a state approach onto a grown app is expensive. Decide it before the second screen.
If most features need native code, the cross-platform argument weakens and native may genuinely be better.
Flutter apps carry their own rendering engine. For a very small utility app the baseline size can matter.
| Metric | What it tells you | What distorts it |
|---|---|---|
| Shared code percentage | How much is genuinely common. Below about seventy percent the cross-platform case gets thin. | |
| App size | Flutter apps carry a runtime, so builds start larger than native. Matters for low-end devices. | |
| Cold start time | Startup performance, which is where the runtime cost is most visible to users. | |
| Frame rendering times | Jank, measured rather than felt. The honest check on perceived smoothness. |
We build and support the systems this page describes. Start with a free working proof of concept — no cost, no commitment.