Why Flutter: The Good and The Ugly

I’ve shipped three production apps with Flutter. Two are still running. One we rewrote in native because Flutter couldn’t handle the performance requirements.

Flutter solves real problems, but it’s not the universal solution Google’s marketing suggests. Here’s what I learned.

What Flutter actually does well

Hot reload works. Change your UI code, hit save, see the result in under a second without losing app state. This sounds small but changes how you work. Tweaking layouts, experimenting with animations, fixing UI bugs—all become faster.

Compare this to native development where each change requires a full rebuild. For iOS, that could be 30+ seconds. Flutter’s hot reload genuinely improves productivity.

One codebase, two platforms. Write code once, deploy to iOS and Android. This works for most UI and business logic. You still need platform-specific code for native features, but 80-90% of your code is shared.

For small teams or solo developers, this matters. Maintaining one codebase is easier than two.

Predictable UI across platforms. Flutter renders its own widgets instead of using platform components. An app looks identical on iOS 14 and Android 14. No chasing platform-specific bugs where a button looks different on Samsung vs Pixel.

The downside: your app never looks quite native on either platform unless you put in extra work.

Where it falls short

App size. A minimal “Hello World” Flutter app is ~4MB. Add features and you’re easily at 15-20MB. Native apps start smaller. For markets with expensive data or limited storage, this matters.

Platform integration requires plugins. Need camera access? Find a plugin. Want push notifications? Another plugin. Many plugins work fine. Some are abandoned. Some have bugs that never get fixed.

You’re dependent on plugin maintainers, and Flutter’s ecosystem isn’t as mature as React Native or native development.

Performance hits for complex UIs. Most apps run fine, but complex list views with heavy images or animations can drop frames. Native development gives you more control to optimize.

I hit this on a social feed with videos and images. We couldn’t get smooth 60fps scrolling in Flutter. Rewrote that screen in native and the problem disappeared.

Updates break things. Flutter updates more frequently than platform SDKs, which sounds good until an update breaks your build. Migration guides exist but they’re not always accurate. Budget time for dealing with breaking changes.

When I use Flutter

MVPs and prototypes. When you need to validate an idea fast across iOS and Android, Flutter’s speed is worth the tradeoffs. Build, test, iterate quickly.

Internal tools. Apps for employees where app size and native feel matter less. Focus on functionality over polish.

Consumer apps with standard UIs. Forms, lists, basic navigation, simple animations—Flutter handles these well. If your app fits this pattern, it’s a solid choice.

When I don’t use Flutter

Performance-critical apps. Games, video editing, real-time graphics—use native or a game engine. Flutter’s rendering overhead will hurt.

Heavy platform integration. If most of your app is calling native APIs, the abstraction layer Flutter adds isn’t worth it. Just write native.

Apps that need to feel native. iOS users notice when scrolling physics feels wrong or navigation patterns don’t match platform conventions. Flutter can mimic native behavior, but it requires effort and never feels quite right.

The Dart language

Flutter uses Dart, which is… fine. It’s a decent language that borrows from Java, JavaScript, and C#. If you know any modern language, you’ll pick up Dart quickly.

The problem is Dart has no use outside Flutter. Learn Swift and you can write iOS apps and server code. Learn JavaScript and you can write web, mobile (React Native), and server apps. Learn Dart and you can write Flutter apps.

This isn’t a dealbreaker, but it means Dart knowledge doesn’t transfer as well.

The ecosystem

Flutter has decent tooling. VSCode and Android Studio have good plugins. DevTools for debugging works well. The package ecosystem on pub.dev is growing but still smaller than npm or CocoaPods.

Popular apps built with Flutter include Google Ads, Alibaba’s Xianyu, and BMW’s app. These prove Flutter can handle production scale, though you don’t hear much about the apps that got rewritten in native.

The honest assessment

Flutter is a pragmatic choice for many projects. It’s faster than writing two native apps. It works well for standard UIs. Hot reload genuinely improves development speed.

But it’s not magic. You’ll hit platform quirks. Plugin quality varies. Performance can be an issue. App sizes are larger. Updates sometimes break things.

Use Flutter when development speed and code sharing outweigh the downsides. Don’t use it when you need maximum performance, deep platform integration, or pixel-perfect native feel.

Like any tool, it solves some problems well and others poorly. Choose based on your constraints, not the hype.