React Native vs Flutter: Why We're Sticking with React Native
By Ehsan2025 Update: Both frameworks have evolved significantly since 2019. React Native now has the New Architecture (Fabric renderer, TurboModules, Codegen) delivering near-native performance and better native module integration. Flutter 3.x brings improved performance, Material 3 design, and better desktop/web support. The decision criteria from 2019 still apply—choose based on your team's existing skills. If your web team uses React, React Native offers massive code sharing benefits. If you're starting fresh or value Flutter's widget system and Dart type safety, Flutter is excellent. Both frameworks power major production apps. The "which is better?" debate is less relevant now—both are mature, both ship quality apps.
Introduction
Flutter 1.7 just dropped in July, and it's getting a lot of attention. With a new project starting at Curalie GmbH, this seemed like the perfect time to evaluate Flutter seriously.
I've been building with React Native since early 2016, and our current medical app is written in RN. But I don't want to stick with something just because it's familiar. If Flutter is genuinely better for our needs, we should consider switching.
After spending time researching Flutter, testing it out with a small prototype, and comparing it against our specific requirements, we've decided to stick with React Native. Here's why.
Our Context at Curalie
Before diving into the comparison, let me explain what we're building. Context matters when choosing technology.
Our situation:
- We're a medical product company in Germany
- Building apps that handle sensitive patient data
- Our web team uses React
- Current mobile app is React Native
- Team of 5 mobile developers, all experienced with RN
- New project launching soon
Technical requirements:
- Complex forms for medical data entry
- Video and audio recording capabilities
- Bluetooth connectivity to sync data from medical devices
- Native module integration for device-specific features
- Must be reliable and maintainable
With that context, let's look at both frameworks.
What's New in React Native 0.60
React Native 0.60 came out on July 3rd, and it's a significant release. Let me highlight what matters most:
Auto-linking
Finally! No more manually linking native dependencies. This has always been the troublemaker during builds. Now when you install a package, it automatically links—just like npm packages work on the web.
# The old way
npm install react-native-camera
react-native link react-native-camera
# Then manually fix issues in Xcode/Android Studio
# The new way (for libraries that support it)
npm install react-native-camera
# Auto-linking handles it
It doesn't work perfectly with every library yet—many popular packages still need manual linking. But the ones that have adopted auto-linking work smoothly. I'm hoping most common libraries catch up and adapt to this quickly. When the ecosystem fully supports it, this will be huge for productivity.
AndroidX Support
React Native now uses AndroidX instead of the old Android Support Libraries. If you're working with modern Android libraries, this removes a lot of compatibility headaches.
CocoaPods by Default (iOS)
iOS projects now use CocoaPods as the default dependency manager. This standardizes how we handle iOS dependencies and makes managing native modules cleaner.
Upgraded to React Hooks
React Native 0.60 fully supports React Hooks. I wrote about why Hooks are a game changer—they're fantastic, and having them in React Native makes components so much cleaner.
// Using Hooks in React Native now
function PatientForm() {
const [patientData, setPatientData] = useState({});
const [isSubmitting, setIsSubmitting] = useState(false);
useEffect(() => {
// Load existing patient data
loadPatientData();
}, []);
return (
// Form UI
);
}
These improvements make React Native 0.60 feel polished and mature.
What's New in Flutter 1.7
Flutter 1.7 also came out in July, and Google is pushing it hard. Here's what stood out:
AndroidX Support
Like React Native, Flutter now supports AndroidX. Good timing—both frameworks are aligned here.
Improved Desktop Support
Flutter is expanding beyond mobile to desktop. That's interesting for future projects, but not relevant to our mobile-focused work right now.
Better Tooling
Flutter's development tools keep getting better. Hot reload is fast, and the widget inspector is genuinely useful for debugging UI issues.
Growing Package Ecosystem
Flutter's package ecosystem is growing quickly. More packages means less custom work, which is always good.
The Technical Comparison
Let me break down how they compare on factors that matter for our medical app.
Performance
Flutter:
- Compiles to native ARM code
- Consistently smooth 60fps
- No JavaScript bridge overhead
- Fast startup times
React Native:
- Uses JavaScript bridge for native communication
- Generally smooth, but can have performance issues with complex UIs
- Improving with each release
- React Native 0.60 has better performance than earlier versions
Winner: Flutter (slightly)
Flutter's compiled approach does give it a performance edge. But honestly, for most apps including ours, React Native's performance is more than sufficient. We haven't hit performance walls in our current medical app.
Development Speed
Flutter:
- Hot reload is extremely fast
- Single codebase for iOS and Android
- Dart is easy to learn
- Good documentation
React Native:
- Hot reload is fast (Fast Refresh in 0.60)
- Single codebase for iOS and Android
- JavaScript is what our team already knows
- Massive community with tons of resources
Winner: React Native (for us)
Our team knows JavaScript. Our web developers know React. There's no learning curve. With Flutter, we'd need to learn Dart and Flutter's widget system. That's time we could spend building features instead.
Native Module Access
Flutter:
- Can write platform channels to access native features
- Growing plugin ecosystem
- Still young, so some features require custom work
React Native:
- Mature native module system
- Huge library ecosystem
- Most common features already have packages
- Easy to write custom native modules when needed
Winner: React Native
We need Bluetooth connectivity to sync medical device data. We need custom video recording. We need specific native features for HIPAA compliance.
React Native has mature packages for all of this. Flutter's ecosystem is growing, but it's not there yet. Building custom platform channels would take significant development time.
UI Components
Flutter:
- Material Design and Cupertino widgets out of the box
- Pixel-perfect UI across platforms
- Extensive customization options
- Consistent behavior on all devices
React Native:
- Uses actual native components
- Feels native because it is native
- Platform-specific differences (sometimes annoying, sometimes good)
- Rich third-party component libraries
Winner: Depends on your needs
Flutter's approach is great if you want identical UI on iOS and Android. But we actually like that our app feels native to each platform. iOS users expect iOS patterns. Android users expect Material Design.
React Native's use of native components means our app automatically follows platform conventions. That matters for a medical app where users need to feel comfortable and confident.
Forms and Complex UI
Flutter:
- Declarative widget composition
- State management with Provider, BLoC, etc.
- Good form handling
React Native:
- Component-based like React
- State management with Redux, MobX, Context, etc.
- Many form libraries available (Formik, React Hook Form)
Winner: Tie
Both handle complex forms well. Since we already have patterns established in React Native and our team knows Redux, there's no advantage to switching.
Debugging and Development Experience
Flutter:
- Excellent DevTools
- Widget inspector is fantastic
- Clear error messages
- Good debugging experience in VS Code and Android Studio
React Native:
- React DevTools and Redux DevTools
- Flipper for debugging
- Chrome DevTools integration
- Error messages can be cryptic sometimes
Winner: Flutter (slightly)
Flutter's debugging tools are really impressive. The widget inspector makes it easy to see exactly what's happening in your UI. React Native's tools are good, but Flutter has an edge here.
Community and Ecosystem
Flutter:
- Backed by Google
- Rapidly growing community
- Increasing number of packages
- Good documentation
- Young ecosystem (started 2017)
React Native:
- Backed by Facebook (and now community-driven)
- Massive, mature community
- Huge package ecosystem
- Tons of blog posts, tutorials, Stack Overflow answers
- Mature ecosystem (started 2015)
Winner: React Native
When you hit a problem at 2 AM (and in medical software, that happens), you want community support. React Native's community is huge. Almost every issue we've encountered, someone else has already solved and posted about.
Flutter's community is growing fast, but it's not there yet. When working on a critical medical app, that matters.
Our Decision: Sticking with React Native
After evaluating both, we're staying with React Native for our new project. Here's why:
1. Team Knowledge
Our entire team knows JavaScript and React. Our web team uses React. Switching to Flutter means:
- Learning Dart
- Learning Flutter's widget system
- Learning new state management patterns
- Building new team conventions
That's months of reduced productivity while we learn. For a startup, that's expensive.
2. Code Sharing with Web
Our web app is React. With React Native, we have the option to share:
- State management logic
- Business logic
- Data models
- API calls
With Flutter, we'd lose that code sharing. We'd essentially maintain two separate codebases.
3. Native Module Ecosystem
We need mature packages for:
- Bluetooth Low Energy communication
- Medical device integration
- Video recording with specific requirements
- Audio capture
React Native has production-ready packages for all of this. Flutter's ecosystem is growing, but we'd need to write custom platform channels for several features. That's development time we don't have.
4. Existing Codebase
Our other project is written in React Native. If we use Flutter for the new project, we'd maintain two different mobile tech stacks.
That means:
- Two sets of build configurations
- Two deployment pipelines
- Split team focus
- Can't share components between apps
With React Native, we can share code, components, and knowledge between projects.
5. React Native 0.60 Improvements
React Native 0.60 addresses many of the pain points we've had:
- Auto-linking removes dependency headaches
- Hooks make code cleaner
- Performance improvements
- Better AndroidX support
The framework is maturing in exactly the ways we need.
When Flutter Makes Sense
I want to be clear—this isn't "React Native is better than Flutter." For our specific situation, React Native is the right choice. But Flutter makes a lot of sense if:
You're starting fresh:
- No existing React Native codebase
- No React web app to share code with
- Team is willing to learn Dart
You want pixel-perfect UI:
- Need identical appearance on iOS and Android
- Designing custom, non-native interfaces
- Heavy focus on animations and visual polish
You're building for multiple platforms:
- Planning desktop apps alongside mobile
- Want to target web, mobile, and desktop with one codebase
- Flutter's cross-platform support is impressive
Performance is critical:
- Building a game or graphics-heavy app
- Need consistent 60fps with complex animations
- Flutter's compiled approach shines here
You love Dart:
- Some developers really enjoy Dart's type system
- If your team prefers strongly-typed languages, Dart is nice
The Real Talk: Both Are Good
Here's the honest truth—both React Native and Flutter are excellent frameworks. You can build great apps with either one.
Flutter's performance is impressive. The development experience is smooth. The tooling is top-notch. If I were starting a personal project or a gaming app, I'd seriously consider Flutter.
But technology choices aren't just about which framework is "better." They're about:
- What your team knows
- What your existing codebase uses
- What your ecosystem looks like
- What your requirements are
- How much time you have
For Curalie, React Native is the pragmatic choice. We're productive with it. Our team knows it. Our codebase is built on it. React Native 0.60's improvements address our pain points.
Looking Forward
Both frameworks are evolving quickly:
React Native's roadmap:
- Better debugging tools
- Improved performance
- Better TypeScript support
- Continued auto-linking improvements
Flutter's roadmap:
- More packages and plugins
- Better web support
- Expanded desktop support
- Continued growth
I'll keep watching Flutter. In a year or two, the ecosystem might be mature enough that switching makes sense. But for now, we're confident in our decision.
For Teams Making This Choice
If you're evaluating React Native vs Flutter, ask yourself:
Team questions:
- Does your team know JavaScript/React or Dart/Flutter?
- Do you have a React web app?
- How much time can you spend learning?
Technical questions:
- Do you need specific native features?
- Are there packages available for your requirements?
- Is performance critical for your app?
Business questions:
- Do you have existing React Native code?
- How fast do you need to ship?
- Can you maintain multiple tech stacks?
There's no universal right answer. Evaluate based on your specific situation.
Conclusion
We're sticking with React Native for our new medical app at Curalie. The combination of team knowledge, code sharing with our React web app, mature package ecosystem, and React Native 0.60's improvements makes it the clear choice for us.
Flutter is impressive, and I'm excited to see where it goes. But right now, for our team and our requirements, React Native is the better fit. With modern tools like Jotai for state management, Maestro for E2E testing, and NativeWind for styling, React Native development is more productive than ever.
Both frameworks are pushing mobile development forward. The competition between them is making both better. That's great for all of us building mobile apps.