Native vs Cross-Platform Development: How to Choose for Your App
For most business apps – catalogues, orders, bookings, customer accounts – a cross-platform framework such as Flutter or React Native is a sensible default: one codebase produces apps for both iPhone and Android. Native development, with each app built separately in its platform's own tools, earns its higher cost when the app depends on the device itself: sensors, location in the background, Bluetooth hardware or demanding graphics. Hybrid apps (web pages inside an app shell) and progressive web apps suit simple, content-led cases, within clear limits. Choose by the hardest features your app must get right, not by fashion.
The four approaches in plain terms
Native
A separate app for each platform, written with the platform's own languages and tools – typically Swift for iOS and Kotlin for Android. You get immediate access to every platform feature and to the platform's standard interface components. The cost: two codebases, and usually two sets of skills.
Cross-platform
One codebase, two apps. The main frameworks work differently under the hood:
- Flutter draws its own interface. Its documentation explains that Flutter has its own implementation of each UI control rather than using the system's, and that release builds are compiled directly to machine code. Device features are reached through plugins – the docs mention thousands, covering things such as the camera and Bluetooth – or through custom platform code via "platform channels".
- React Native uses JavaScript and React; at runtime it creates the corresponding Android and iOS views, so, in its documentation's words, apps "look, feel, and perform like any other apps". You can also write your own native components when needed.
- Kotlin Multiplatform takes a third route: share the business logic while keeping the interface native, or share the interface too with Compose Multiplatform.
A detailed comparison of Flutter and React Native is a topic of its own. For most business apps either can do the job, and the skills of the team that will maintain the app often matter more than the framework.
Hybrid (web view)
Your web pages, displayed inside a native app shell, with plugins for some device features. It is the quickest route if you already have a good mobile website. The risk is an app that is little more than the website: Apple's App Review Guidelines say an app "should include features, content, and UI that elevate it beyond a repackaged website".
Progressive web app (PWA)
A website that can be installed on the home screen and work partly offline, with no app store involved. It is the cheapest way to an app-like experience, but it lives within browser limits. The W3C Geolocation specification, for example, states that position updates "are exclusively for fully-active visible documents" – a PWA cannot keep recording a route once it is in the background.
How they compare
| Native | Cross-platform | Hybrid | PWA | |
|---|---|---|---|---|
| Codebases | Two | One (plus some native code if needed) | One web codebase plus a shell | One |
| Access to device features | Full and immediate | Wide, through plugins or custom native code | Partial, through plugins | Only what browsers allow |
| Demanding real-time work | Best fit | Usually fine; heavy parts may need native code | Weak | Weak |
| App stores | Yes | Yes | Yes, if it passes review | No |
| Typical fit | Device-centred apps, single-platform apps | Most business apps on both platforms | Store presence for an existing good mobile site | Content, simple tools, internal use |
When device access decides: the roadmeter.app example
roadmeter.app measures trips, 0–100 km/h acceleration, braking and track laps using the phone's GPS and sensors, and ranks results using car data from auto-data.net. It is available on Android, with an iPhone version coming. For an app like this, the deciding questions are not about screens but about the device:
- Which sensors exist? Android's documentation notes that manufacturers aren't required to include any particular sensors, so an app must check at runtime what is available.
- How often can you read them? For apps targeting Android 12 or higher, the system limits the sampling rate of motion sensors read through the standard listener to 200 Hz unless the app declares a special permission.
- What happens in the background? On Android 9 and later, apps in the background don't receive continuous sensor events such as accelerometer and gyroscope data; Google recommends reading sensors while the app is in the foreground or from a foreground service.
- Could the web do it? Not this: the browser stops position updates when the page is hidden.
Whatever framework you pick, someone on the team has to work at this level of the platform. With a cross-platform framework, that work happens in plugins or custom native code; with native development, it is the everyday toolset. That is why device-centred apps often lean native. Starting on one platform can also be a reasonable way to prove the idea before building the second version – roadmeter, for example, launched on Android first.
Which approach for which app
- Native – the app is built around sensors, background location, Bluetooth hardware, augmented reality or heavy graphics, or you only need one platform.
- Cross-platform – a typical business app on both platforms, maintained by one team: catalogue, orders, bookings, loyalty, customer account.
- Hybrid – you already have a good mobile website, need a store presence and a few device features, and the app adds real value beyond the site.
- PWA – content, simple tools or internal apps where app stores and background work aren't needed.
Questions that settle the choice
- What are the three hardest features? Do any of them need hardware access or background work?
- Do you need both platforms at launch, or can one come first?
- Who will maintain the app in three years, and what skills does that team have?
- Is there a website or back end you can reuse?
- What is the smallest first version that is still useful? Our guide to defining an MVP helps here.
What doesn't depend on the choice
Every approach needs a reliable server and an API that keeps working for older app versions people haven't updated (see one API for a website and a mobile app), testing on real devices, clear permission requests and attention to store rules. When a store changes its requirements, that is a real reason to release an update; chasing every new framework version for its own sake is not.
If you are planning an app, describe what it must do – especially the hardest parts – and we will recommend the approach that fits your features, your budget and the people who will maintain it. See our mobile app development service or contact us.