The mobile has become the main content distribution platform for companies, an essential means of accessing work-related data, and a key doorway for completing multiple transactions. When developing mobile apps, there are two options: going native or building cross-platform. How are these two approaches to mobile development different? What are the best use cases for each? Let’s find out.
We all consume content galore on our mobile phones. But what truly defines our experience is content presentation. Indeed, we’re all familiar with the smooth transitions of those great apps on our phones, often feeling the urge to come back for more of that good usability.
Just a few years ago, that’s exactly how native apps were sifted from the cross-platform wannabes—the quality of the latter simply wasn’t good.
The beginnings of cross-platform mobile development were harsh, to say lightly.
But back in the day, there were many players on the scene of mobile operating systems. You had Windows, BlackBerry, iOS, and Android. Building affordable applications that could run on all the platforms was justifiable.
The need for a wider reach resulted in a compromise on slow performance, bad usability, and frequent crashes for the small price businesses had to pay for hybrid applications. The cross-platform mobile development tools and frameworks were immature and not really ready for production.
In 2015, things started to change. First, React Native entered the scene, giving the apps built with it a semblance of nativity (React Native binds to native UI components). Then, in 2018, Google released Flutter, which allowed developers to build native-like apps.
Still, the two technologies were unable to beat native applications both in terms of performance and usability. Besides they lacked the maturity necessary for long-lived projects that require steady support and maintenance.
Fast forward to 2020. Cross-platform development technology bloomed and is now mature enough to produce high-quality offspring. And even though there still are cases where native apps outperform hybrid applications (which we will discuss below), the difference between the two ceased to be so jarring.
While there are currently quite a few decent cross-platform mobile development tools (Cordova, Ionic, NativeScript, or Xamarin), we will be focusing here on only two—React Native and Flutter.
Without further ado, let’s kick off the comparison with a quick what’s what in the world of hybrid and native mobile development.
Native applications are written in programming languages and Software Development Kits (SDK) delivered by the providers of operating systems (OS) they run on:
Hybrid applications are written in programming languages and development tools offered by companies unaffiliated with mobile platform provider
Native applications are executed without prior interpretation of the code, which results in fast apps with a familiar look and feel.
Hybrid applications can be split into two categories:
Each app type has a different target audience and different requirements, which have to be analyzed in detail to make an informed decision on which mobile development approach to pick. Use the guide below to determine which tech stack is better for your mobile app.
The biggest consideration business owners usually give mobile app development is cost.
Developing a native application for iOS and Android essentially equals building two separate applications maintained by two separate teams of developers. Naturally, this can be a costly undertaking.
With hybrid applications, the app code is developed by one team. This doesn’t mean hybrid app development cost is cut in half compared to a native approach, but having a single codebase and one team of devs certainly drives the cost down. But there’s a caveat.
In complex applications, you have to use bridges and plugins to gain access to platform-specific features—these have to be written in native code, which calls for developers that have substantial knowledge of either platform.
Application complexity is one of the key determiners when choosing between native and cross-platform development.
A good way to define app complexity is to count the number of features, frameworks, and SDKs included in the application—or in other words, the more the app depends on device or OS features (bluetooth, GPS, gyroscope, accelerometer, file sharing, etc.), the more complex it is. App complexity isn’t the number of screens—an app with 200 screens can have little dependence on device and OS resources.
While platform integration is easier when using native SDKs, hybrid mobile development might call for additional cost and potential overhead included in the adoption or development of bridges/plugins that integrate with platform- and device-specific functionalities.
Reducing time-to-market is one of the main objectives for companies wanting to release an application. Developing two native applications simultaneously will require significant resources and a sizable development team.
With cross-platform mobile development, time-to-market is reduced because the code can be reused across platforms. While the amount of code reuse depends on the project, it’s not uncommon to reuse up to 90% of code. The code can also be shared with the web version of an app, especially the business logic.
When a lot of the code is reused, you can end up with a uniform application that doesn’t leverage platform-specific features.
Smooth user experience and fluid UI transitions are crucial characteristics of good apps, characteristics that should remain unchanged even during heavy data processing. Native mobile development tools offer solutions that delegate data-processing operations to separate threads, ensuring a seamless user experience.
In the past, hybrid-web apps used to perform many operations simultaneously, on the same thread, causing the UI to respond poorly. Currently, however, there are solutions that let hybrid-web apps delegate processes to background threads, which frees up resources. App performance with this approach is still affected, though.
But this is not the case with hybrid-native apps built in React Native or Flutter, which approach the matter differently.
Flutter—renders UI elements using a highly performant engine, which results in performance on par with natively developed applications.
In native applications, when a new OS version is out, the language and tools are supported instantly, adopting new features automatically.
In cross-platform development, there can be a delay in the introduction of new-feature support for hybrid tools and frameworks. Moreover, to reflect the changes implemented in the new release of the OS, you might need to modify the hybrid app code—otherwise, especially if the changes are considerable, your application might not work properly with the new OS.
The lifetime of a mobile application is significantly shorter than that of many software solutions. But we can safely assume three years to be a decent lifespan of a mobile app before it needs a rewrite.
With that in mind and depending on the mobile app type, choosing a native stack is generally preferable for apps that are intended to stay longer on the market (i.e., longer than three years).
But if you’re building a short-lived ap (e.g., a marketing app to support a one-time event), choose hybrid development—it’ll be cheaper and faster to develop an app with good performance.
The mobile world is a dynamic environment. Mobile solutions that once were widely popular have virtually disappeared from the market (e.g., BlackBerry or Windows Mobile).
That’s why it’s important to take into consideration your app’s lifetime when thinking about native or hybrid development. The rule of thumb is, the longer the lifetime, the more it relies on stable technologies with a long-term upgrade roadmap.
Native tech stacks offer a plethora of tools and guides that make it easy to migrate into a new release. Plus, since iOS and Android rule the mobile market, we can safely assume the platforms will be supported for years.
Things are a bit different with cross-platform tools, which might lack the long-term upgrade timeline. And even though Flutter and React Native have arrived at a level of stability and maturity worthy of trust and have developed considerable communities around them, both technologies can be dropped by official developers sometime in the future. This carries the risk that you’ll need to do a major application rewrite a few years after the app release.
After the release of your application, you need to consider app maintenance and new features iteration.
The codebase for a hybrid app is shared across two platforms. Addressing bugs and developing new features is therefore easier because the team has only one code to work with.
The choice depends on a thorough analysis and validation of your budget, app features, audience, and app complexity. Always consult your product development with experienced developers who can help you decide which approach fits your application best.
Key things to remember:
To see how Flutter and React Native look like in action, check out the apps built using these tools.
Companies using React Native:
Companies using Flutter: