Flutter vs React Native: Which Framework Should You Choose?

If you're building a mobile app in 2026, you're making a huge money decision right at the start. You've got to pick a framework that lets your team build one product for both iOS and Android, and that choice really comes down to the classic debate of Flutter vs React Native.

However, the old debate about which one was faster is over. For years, we all argued about raw performance. That's not the real fight anymore.

This is a choice about your team's skills, where you want the product to be in three years, and who you can actually hire where you live (something a lot of founders forget). Getting this wrong will cost you a fortune.

For approximately 90% of products out there, processing speed just isn't the deciding factor. If you get hung up on the wrong numbers, you'll burn through your budget, miss your launch date, and build up years of engineering debt. You must first realize this isn't just a technical choice; it's a business decision with real trade-offs.

Quick Comparison: Flutter vs React Native

What is React Native?

React Native is an open-source framework developed by Meta for building cross-platform mobile applications from a single JavaScript or TypeScript codebase. It lets developers create apps for both iOS and Android while rendering native user interface components, so the finished app behaves much like a traditional native application.

React Native is fundamentally about people; the technology itself is secondary. The whole point is to let your existing team of web developers build your mobile apps. It works by using a "bridge" that talks to the phone's real, native user interface parts. So you're not just drawing a picture of a button; you're telling the actual Apple or Google button what to do.

React Native: Key Strengths and Use Cases

The biggest win with React Native is that you can often skip the nightmare of hiring dedicated mobile developers. A good specialist can take months to find. Instead, your frontend web developers can get up to speed on mobile projects pretty quickly because they already know React.

This makes hiring and training so much simpler. In the UK, for example, the number of available React Native developers is approximately 3.4 times greater than the pool for Flutter. Opting for React Native in 2026 typically means adopting Expo.

These days, if you start a new project in 2026, you're almost certainly going to use a tool called Expo. The official React Native docs even recommend it for new apps. It's used by 81% of the community because it smooths out a lot of the rough edges, especially around compiling your code and getting it onto people's phones.

React Native: Common Weaknesses and Drawbacks

That speed comes with a price. The huge library of community-made packages can get you moving fast, but it also creates a real maintenance headache down the road. If the person who built a key part of your app just decides to stop updating it, your software can break.

On top of that, the way the framework relies on the phone's own UI controls can cause its own set of problems. Because React Native uses the device's built-in components, a standard button might look one way on an iPhone and slightly different on a Samsung phone. This forces your design team to do extra work to make sure your brand looks consistent everywhere.

What is Flutter?

Flutter is Google's open-source UI toolkit for building cross-platform applications from a single Dart codebase. It allows developers to create apps for iOS, Android, web, desktop, and embedded platforms while using the same code and interface across each one.

Flutter takes a completely different approach from React Native. Instead of relying on the buttons, menus, and other interface elements that come built into iOS and Android, it draws everything itself. Every button, animation, and screen is built from Flutter's own collection of widgets, giving your team complete control over how the app looks. That's why companies building highly branded products often gravitate toward Flutter. They're not working around the operating system's design rules; they're creating their own.

Key Strengths and Use Cases of Flutter

Its main selling point is the power to give you a perfectly consistent, brand-approved user experience on every single device you ship to. The framework gets this done by completely ignoring the standard interface controls that come with iOS and Android. Its own graphics engine draws its own widgets, giving you total control.

This approach differs from alternative systems like Kotlin that rely on native platform elements. It also yields exceptional uniformity when building layouts. A team can build complex, pixel-perfect designs and know they'll look identical everywhere, without being limited by what the phone’s operating system wants to do.

Through a process called ahead-of-time compilation, Flutter apps are translated directly into the native machine code of the phone or computer they're running on. Instead of relying on the platform's built-in visual parts, Flutter uses its Skia engine to paint every component right onto the glass. The result is an app that not only looks the same everywhere but also performs reliably, consistently hitting 58 to 60 FPS even when the graphics get intense.

Common Weaknesses and Drawbacks of Flutter

The biggest barrier to entry with Flutter is its total dependence on the Dart programming language. Choosing this framework means a team has to get good at Dart, which creates a real learning curve (and a large amount of work) for companies where all the engineers are already fluent in JavaScript, Swift, or Kotlin.

In some markets, the larger app size is a more immediate problem. The trade-off for guaranteeing that UI control is that your app has to package its own rendering engine to take with it. This means the final application file is typically heavier, frequently coming in 10-20MB larger than a React Native app. In areas where cellular data is expensive or limited, this overhead is an important business factor.

Financial and Timeline Considerations

You need to think about your app's budget for launch and for the long haul. When you pick a framework, you're making a multi-year financial bet that goes way beyond your first invoice. It’s a classic mistake to see a quick, cheap launch as a win, because the real cost of your app isn't what you pay to build it. It's what you pay over years to maintain, update, and keep it from breaking.

Total Cost of Ownership and MVP Costs

React Native often looks like the cheaper option to get started. If you have web developers on staff, you can build a minimum viable product in approximately six months for $40,000. A Flutter project will likely require a higher initial investment of $45,000.

But that upfront "savings" with this framework disappears fast. In the first year alone, you can expect to pay nearly $20,000 for maintenance, compared to about $12,000 for a Flutter app. A good rule of thumb for monthly maintenance is to plan to allocate between 15% and 20% of the initial creation budget annually.

When you look out three years, the numbers get even clearer. You should plan on spending between 15% and 20% of your original development cost every single year just for basic upkeep, things like software updates and security patches. For a $50,000 app, that’s roughly $625 to $833 a month just to keep the lights on.

And that doesn't even include new features. For every major feature you want to add, you should budget another 25% to 50% of the original project cost.

Time-to-Market and MVP Development Speed

Of course, your framework choice directly affects how fast you can build. On my first mobile project, I did what most people do and picked the framework my team already knew. (I certainly did.) For a while, we were flying, using its huge library of ready-made components for all the standard stuff.

But as soon as we needed a highly custom user interface, things ground to a halt. If your project is design-heavy, Flutter is often the faster choice because you aren't fighting the native platforms. The "faster" option really just depends on what you're building.

Ecosystem and Tooling Maturity

You have to weigh the ecosystem on two different scales: its sheer size versus its reliability. With React Native, you're getting a massive, sprawling community library and tools like Expo. Thankfully, you'll find that the New Architecture is now compatible with approximately 85% of the most-used packages.

If you value stability over endless choice, Flutter is the safer bet. Google directly manages and updates the essential libraries you'll need, like Firebase and Google Maps.

Flutter is famous for its hot reload feature, which lets developers see their code changes on screen in under one second without restarting the app. That's a huge productivity boost. The trade-off is that you're working in a smaller, more contained world. With Meta's framework, you're tapping into an ecosystem where about 81% of engineers are already using the Expo toolsuite to build and ship software.

Team and Hiring Implications

Your framework choice is a people one that decides who you can hire and what you will pay them. There is a deep pool of JavaScript and React talent, so many web developers can make the switch easily. Flutter specialists, on the other hand, are harder to find.

Developer Availability and Hiring Costs

There are 3 to 5 times more JavaScript developers than Dart developers, and many application developers transition easily from web roles. Finding qualified personnel for React Native projects is typically less difficult in the United Kingdom. For Flutter, companies must execute a more targeted talent search.

Though Flutter employment listings are growing about 31% year on year, its smaller talent pool comes at a price. You are still looking at a 10 to 15% salary premium for engineers who know Dart. A senior developer salary of $125K to $160K for a JavaScript-based role jumps to $135K to $180K for a Flutter one.

To find talent, you can use agencies on sites like Clutch.co and GoodFirms. For freelancers, Toptal is known for its strict evaluation of contractors, while Upwork provides a massive selection of individuals. For Flutter experts, organizations can locate certified advisors on the verified Flutter Community portal. You can also search on GitHub to see who is actively building with the technology.

Programming Language and Team Learning Curve

The language itself is the biggest hurdle. If your team is full of people who live and breathe JavaScript, they can get going with the Facebook-backed framework almost immediately. Opting for React Native allows them to apply their established expertise almost instantly.

But when you choose Flutter, you are also choosing to pay for your team's education in Dart. While learning it can be great for them, it is a real cost for the business.

That cost shows up on the calendar. You can expect a seasoned JavaScript programmer to be productive in React Native in 2 to 3 weeks. For a developer who is new to Dart, you will need to budget 4 to 6 weeks for them to get up to speed on Flutter.

The 2026 Architectural Changes Affecting Performance

For a long time, the whole debate about Flutter vs React Native was just about speed. Engineers would argue back and forth about raw performance, but honestly, that whole argument is history. It's a distraction. Both frameworks have gone through huge architectural changes that have pretty much closed the performance gap.

The old benchmarks are useless. Now, the technical performance is good enough on both sides, which is great news. It forces you to think about what actually matters for your business: your team and budget, and what you want your brand to feel like.

React Native's New Architecture: Fabric and JSI

What was React Native's big fix for its historical bottleneck? The old architecture was like having two sides of your company, the JavaScript side and the Native side, that couldn't speak to each other. To get anything done, they had to send messages back and forth through a slow, clunky courier called the Bridge. It was a mess.

The new setup replaces that with something called the JavaScript Interface, or JSI, which is basically a direct line between the two. This permits immediate, real-time discussions between the two sides, so your JavaScript code can call native functions instantly. All those old critiques are out the window.

The new Fabric renderer helps, too. It sends drawing instructions straight to the phone’s native layout system, which makes UI updates faster and more reliable. You get much smoother scrolling and a graphics pipeline that just works without all the old delays.

And now we're in territory that matters to a lot of people. They also added TurboModules, which are components that only load when you actually need them. This cuts down on memory use and makes the app start up faster, shortening launch sequences.

On top of that, its JavaScript engine, Hermes, pre-compiles your code, which also helps with launch times and shrinks the installation package. The legacy system, by contrast, acted more like an office clerk managing paperwork.

Flutter's Impeller Rendering Engine

Imagine an artist trying to paint. Before the new engine, Impeller, it was like they had to stop drawing every few seconds to mix a new color; an illustrator must halt work to blend physical paints for a new shade. This created visible pauses, or stutters.

You’d see these little pauses and hitches. Impeller is like giving that artist a full palette of colors already mixed and ready to go, so they can just paint smoothly without interruption.

Technically, what Impeller does is get rid of on-the-fly shader compilation. This cures the classic issue of stuttering caused by that runtime compilation. It prepares all the shaders it needs ahead of time when the app is built, not while it's running. This guarantees you get fluid graphics right from the start.

It pulls this off by talking directly to the low-level graphics hardware, using APIs like Metal on iOS and Vulkan on Android. This direct communication keeps the frame rate steady, even when the app is doing a lot of work. The result is that for really demanding layouts, the average time it takes to render pixels drops by nearly 50%.

Performance Metrics: FPS, Startup, and Battery Use

A key difference emerges when you look at the trade-offs. It’s a trade-off. Flutter’s big advantage is its absolute consistency.

Because it brings its own graphics engine, it can maintain a rock-solid output of 58 to 60 FPS even under heavy load. React Native, on the other hand, uses the phone’s built-in OS components, which gives it an edge in other areas.

The numbers tell the story. A 2025 benchmark from SynergyBoat on iOS showed Flutter hitting 0% dropped frames and 0% janky frames. The same test showed React Native (Fabric) with a frame loss rate of 15.51% and 1.8% janky frames. (For context, a native Swift app had 1.61% dropped frames.) But when you look at other metrics, React Native can start up around 200ms faster and, in specific experimental scenarios, use roughly 12% less battery.

That SynergyBoat report also found the root cause for React Native’s higher frame loss was tied to delays in how it synced up with the screen’s refresh rate during continuous drawing. It’s a complicated picture, but the main takeaway is that both are now so good that the "best" one depends entirely on what you're trying to build.

Core Technology and User Experience

Once you get how these two frameworks actually build a screen, the business choice you have to make becomes very, very simple. React Native is basically an interpreter. It takes your code and translates it into the standard user interface parts that are already on the phone. Flutter is more like a painter.

It shows up with its own easel and paints and draws every single pixel on a blank canvas. This forces your hand. You have to decide if you want an app that feels like it belongs on the operating system, or an app that looks exactly like your brand, everywhere.

How Each Framework Approaches User Interface Design

The easiest way to think about it is that React Native interprets, and Flutter paints. One translates your app into the buttons and menus a user already knows, and the other brings its own and paints them from scratch.

What this means in practice is that a React Native app uses the phone’s actual controls. It’ll have Apple’s look on an iOS device and Google’s Material Design on an Android. Flutter doesn’t care what phone it’s on.

It builds the whole display from its own library of widgets, which gives you absolute control and a consistent look on every single platform. For designers, that’s the holy grail, total authority over every pixel. (Pay a lot of attention to your users' opinions though!)

You can see this for yourself. Go download an app like Coinbase or Shopify to see how React Native feels right at home on your phone. Then, open up the Google Pay or BMW app.

You’ll immediately see Flutter’s custom, brand-first approach. The philosophies are just completely different. React Native provides a native aesthetic, while Flutter provides absolute cross-platform UI uniformity.

Capabilities for AI and Heavy Computation

When it comes to heavy lifting on the device itself, Flutter has a clear technical edge. It has a feature called `Dart's Isolates` that lets it run demanding jobs in their own parallel tracks, each with its own private memory. They have dedicated, non-shared memory pools, eliminating standard multithreading errors. 

This is a huge deal because it completely sidesteps the classic bugs you get when different threads fight over the same memory. `React Native`, on the other hand, is stuck with JavaScript’s single-threaded design.

Now, to be fair, both frameworks can hook into native C++ libraries for things like AI and machine learning. Flutter uses its Dart FFI to pull in files like TensorFlow Lite directly. React Native gets a similar result with its JSI layer, which lets it connect quickly to C++ APIs like Android’s NNAPI or Apple’s CoreML.

A simple scenario makes the difference obvious. Imagine your app is rendering a huge media file in the background while the user is scrolling through an interactive feed. With `Dart's Isolates`, that background task stays in its own lane, and your user never sees a single dropped frame or a frozen screen.

Long-Term Maintenance and Scalability

Building the app is the easy part. The real cost, the one that eats your budget, shows up a year or two down the road during long-term maintenance. You're basically choosing between two different kinds of risk.

React Native gives you access to a massive library of community-built tools. The trade-off is that your team is now responsible for making sure all those moving parts work together without breaking.

Flutter, on the other hand, gives you a smaller, more curated toolkit that Google manages directly. This means fewer choices, but it also means a lot less maintenance work. So, which is better? It really comes down to what your team can handle.

Maintenance, Stability, and Dependency Management

The giant ecosystem for React Native looks like a huge win at first. However, that freedom creates its own kind of long-term headache. I’ve seen projects get completely stuck on an old version of the framework because one critical, but now abandoned, library wouldn't update.

When the core framework gets an upgrade, those community packages can get left behind, and your app starts to break. Your team is then left scrambling to find and plug in a replacement.

Flutter was designed to avoid this exact problem. Google writes and maintains a whole suite of standard modules itself, keeping them right inside the main project. It also doesn't use the phone's built-in UI controls, which means system updates from Apple or Google rarely mess with how your app looks or feels.

So, if you're talking to a potential React Native partner, ask them to explain their precise strategy for supervising external code packages, and how their team intervenes when a vital library is discontinued or causes a system crash following an operating system upgrade. A solid answer will get specific. 

They'll talk about proactive steps, like using automated tools like Dependabot for monitoring, having a structured protocol for auditing fresh libraries, and even budgeting for preventative code updates. A vague, hand-wavy answer is a huge red flag.

Expanding to Web and Desktop Platforms

When it comes to growing beyond mobile, the two frameworks take completely different paths. The Flutter team builds and officially supports web browsers, Windows, macOS, and Linux right into its core. React Native, in contrast, uses a separate project called React Native Web for browsers and depends on community-led efforts for Windows and macOS.

If your company is already heavily invested in React for your website, this model can be really efficient. You get to share components, testing setups, and general know-how between your web and mobile app development teams, which saves a lot of time.

But for more complex apps, Flutter's web support has a clear edge. It compiles to WebAssembly (Wasm), which gives you a big performance boost. You get near-native execution speeds right in the browser, making it possible to build highly interactive features, advanced data visualizations, or even lightweight games that just wouldn't be practical otherwise.

Making the Final Decision

The decision-making process is often overcomplicated. People get lost for weeks comparing features, running performance tests, and building elaborate spreadsheets to decide. You can stop all that. This isn't a technical decision, it's a business one.

Ultimately, your choice boils down to a single question. What's your most valuable asset right now? Is it the web development team you've already built, or is it the unique, non-negotiable brand experience you need to create? Your answer tells you exactly which way to go.

When to Choose React Native

Go with React Native if you need to get to market fast. It’s the right call when your main goal is shipping a product, your engineers already know their way around JavaScript and React, and you want hiring to be straightforward. This is for when deploying an initial MVP in the shortest possible timeframe is the priority.

Fast deployment cycles and quick adjustments are more important than deep visual personalization. If your team already has a React web app, you can reuse up to 90% of that code (which is a lot if you've ever done it!).

You’ll hear people bring up Tesla as a key example, but that’s old news; they subsequently shifted their core consumer application to separate native codebases. Today, you should look at companies like Shopify, Coinbase, or even Microsoft Office for better examples of React Native in the wild.

It’s a great fit for transactional apps like a marketplace, a portal for your SaaS product, a scheduling tool, a social platform, or an internal app for your own employees. 

It also works well for any project that needs to pull in a lot of third-party tools and packages, and it is an ideal choice if your architecture is designed to make use of an extensive public repository of external packages.

When to Choose React Native

The argument for Flutter is all about brand. You choose it when your business lives or dies on a unique, highly polished visual experience with complex, fluid animations that have to look identical on every single device. You need total control over every pixel on the screen, giving your design team absolute authority over how elements are drawn.

To create the software paired with its electric vehicles, Xiaomi went with Flutter and cut their development time by 60%. Because the framework can hit a steady 120 FPS, the user experience is incredibly smooth. Your app wins because its design and quality feel superior.

That smoothness comes from how Flutter works under the hood. It doesn't use the standard buttons and menus that come with the phone's operating system. Instead, Flutter talks directly to the graphics hardware to draw its own interface from scratch, communicating directly with the GPU to achieve this.

So if your product's success depends on sophisticated animations, detailed graphics, and keeping that exact same look and feel on both iOS and Android, Flutter is your answer.

Decision Matrix Summary

You can get lost in dozens of features, but the choice really comes down to what you’re protecting: your team or your brand. It’s your existing React team versus your non-negotiable brand identity. From there, the other pieces fall into place.

You get standard OS layouts with React Native versus a completely custom interface with Flutter. You have the ability to share as much as 90% of your code with a React web app, while Flutter gives you a single codebase for all platforms. Hiring means tapping into the huge JavaScript talent pool for React Native or finding more specialized Dart developers for Flutter.

If you’re still on the fence, try this tie-breaker. Ask yourself which of these two potential crises sounds worse: launching an app that might look a little dated after a major OS update (that’s the risk with React Native), or building a beautiful, custom app that’s really hard to maintain over the long haul (that’s the Flutter trade-off). Your gut reaction to that question tells you which path to take.

Future Outlook and Alternatives

Picking a tech stack is one of those decisions that feels permanent because, well, it pretty much is. You’re not just choosing a piece of code; you’re marrying an entire ecosystem of talent, tools, and quirks for years to come. A wrong turn here can lock you into a slow, expensive grind, fighting your own tools while the market passes you by.

And it’s not like these frameworks just sit still. They’re constantly changing, with their corporate parents shifting priorities and new contenders popping up every few years promising to be the one true solution. This isn't a sign of chaos. It's a sign of a healthy industry that’s aggressively trying to solve some really hard problems.

The core choice between React Native’s get-it-done speed and Flutter’s deep brand control isn’t going away. If anything, the rise of alternatives like Kotlin Multiplatform just makes that strategic trade-off even clearer. This is where promising projects die, not with a bang, but with the slow bleed of a thousand tiny delays, all because the tech is working against the team instead of for it.

Official Roadmaps and Future Direction

Your decision today has to account for where these platforms will be in two or three years, not just what they can do right now. I used to think public roadmaps were just marketing fluff, and I once paid a very real price for that mistake on a project I was leading. Don't do that.

Get in the habit of checking in on the official development plans. For your own planning, make it a quarterly task to look at the React blog for React Native updates and the public Flutter roadmap for what’s next with Flutter. This is to analyze upcoming features, currently developed modules, and crucial bug resolutions.

This analysis helps determine what will be required to expand operational reach as the user base grows. This is how you’ll know if the platform you’re betting on will be able to support you as you grow.

The Role of Kotlin Multiplatform (KMP)

Then there’s Kotlin Multiplatform, or KMP, which offers a third path that rejects the all-or-nothing approach. The architecture is built on a really practical idea: separate the app’s brains from its face. 

Your team writes all the core business logic, the complex rules, database calls, and network stuff, just once in a shared block of Kotlin code. The user interface, however, stays completely native, built with the tools platform experts prefer: Swift for iOS and Jetpack Compose for Android.

The big win with KMP is sharing all that expensive, complex logic without giving up a pixel-perfect native user experience. It lets you avoid duplicating effort on the hard stuff while keeping the native UI where it matters most for performance and brand identity. 

This is a world away from a single-engine solution like Flutter, which draws every single button and text field itself. And with its companion, Compose Multiplatform, you can even choose to share the UI if that’s the right trade-off for you, giving you a level of choice the other frameworks don't.

Now, because its ecosystem is less mature, going all-in on KMP for a new project is a higher initial risk than sticking with Flutter or React Native. It is, however, a very natural fit for teams that already have a strong Android background. Of the three big options in 2026, it's also the one growing the fastest in both power and adoption.

In fact, as of May 2025, Kotlin Multiplatform working with Compose Multiplatform is fully production-ready for iOS and is already being used in big software systems like Physics Wallah (which serves 17 million users) and Wrike. 

It becomes your clear leading candidate under three specific conditions: your engineering team is Android-first with deep skills in Kotlin; your product demands a flawless native interface and you have the budget to build it twice; and you’re mostly adding new features into existing native apps rather than starting from scratch.

Frequently Asked Questions (FAQ)

Is the communication bridge still causing lag in React Native?

No. React Native's old reputation for being slow because of the "bridge" is largely outdated. The bridge has been replaced by the JavaScript Interface (JSI), which creates a direct connection between JavaScript and native platform features.

That architectural change removed one of React Native's biggest historical bottlenecks. Today, performance discussions are much more about your app's workload than the framework itself.

Have React Native's performance limitations been completely resolved?

Not completely, but the gap is much smaller than it used to be. React Native still runs JavaScript code, so it carries a little more runtime overhead than Flutter's ahead-of-time compiled Dart code. In practice, those differences are minor for most business applications. Flutter still has an edge for graphics-heavy interfaces, while React Native performs more than well enough for the vast majority of apps.

Which framework is better for AI-powered applications?

It depends on where the AI work happens. Flutter is stronger for graphics-intensive interfaces and complex visualizations, while React Native integrates cleanly with native AI frameworks like CoreML and NNAPI. If your app mainly runs AI models or uses on-device machine learning features, React Native is often the better fit. If it needs to render complex visual outputs smoothly, Flutter has the advantage.

Which framework offers better web and desktop support?

Flutter provides broader first-party support across platforms. It officially supports web, Windows, macOS, Linux, and embedded devices from a single framework. React Native reaches web and desktop through community projects like React Native Web and React Native for Windows. If you already have a React web application, that ecosystem can make code sharing much easier.

Can you migrate an existing native app to React Native or Flutter?

Yes. Both frameworks support incremental adoption, so you don't have to rebuild your entire application from scratch. You can introduce React Native or Flutter one screen or feature at a time, allowing both frameworks to run alongside your existing native code during the migration.

Will Flutter replace React Native?

No. The two frameworks solve different business problems rather than competing to eliminate one another. React Native's biggest advantage is its JavaScript ecosystem and hiring pool. Flutter's strength is delivering a highly customized, consistent user experience across platforms. Which one is better depends on your priorities.

Which framework is more secure for fintech applications?

Both can be secure, but Flutter is often preferred for security-sensitive apps. Because Flutter compiles to native ARM machine code, its application logic is generally more difficult to reverse engineer than bundled JavaScript.

That said, your application's overall security depends far more on your architecture, encryption, authentication, and development practices than on the framework itself.

Which major companies use React Native and Flutter?

Both frameworks are used in production by large global companies. React Native powers apps from Meta (Facebook, Instagram, Messenger), Microsoft, Shopify, Coinbase, Walmart, and Discord. Flutter is used by Google (Google Pay and Google Ads), Alibaba, BMW, eBay, ByteDance, and Nubank.

This isn't a technical puzzle. It's a business decision. You can either get to market faster by using the giant pool of web talent, or you can invest more to get total control over your user experience.

The tech will keep changing, but that choice between speed and control won't. Know your priority in the Flutter vs React Native matchup. Then make your call.