# Native or cross-platform: how we decide

> Build native when the app depends on hardware, system features or platform polish: the camera, background work, widgets, the menu bar. Share one codebase when the app is mostly forms, lists and content behind an API, and the budget matters more than the last details. Most business apps are the second kind, and some are better off as a website.

Every app project starts with the same question, usually asked as a cost question: one codebase or two? The cost matters, but it follows from a more useful question. What does the app actually have to do on the device?

## What is the difference between native and cross-platform?

A native app is written in each platform's own language and interface toolkit: Swift and SwiftUI on iPhone, iPad and Mac, Kotlin and Jetpack Compose on Android, C# and WinUI on Windows. It uses the platform's own controls, so it looks and behaves like everything else on the device.

A cross-platform app is written once, in a shared framework such as React Native, Flutter or .NET MAUI, and runs on several platforms from the same code. On the desktop, Electron and Tauri do something similar by wrapping a web interface in an app window.

Neither is better in general. They are different trades, and the app decides which trade is worth making.

## When is native worth the extra work?

Four signals, roughly in order of weight.

**The app lives on the hardware.** Camera control beyond taking a photo, Bluetooth accessories, NFC, location in the background, health data, or anything in the menu bar. Each platform exposes these through its own interfaces, and a shared framework reaches them through plugins that lag behind or stop being maintained. Camerture, a Mac app we designed and built, adjusts exposure and colour on built-in and USB cameras. That is system integration from the first line, so it is written in Swift.

**The interface is the product.** Camera previews, maps, drawing, long feeds of images, gestures that have to feel right on a 120 Hz screen. Native toolkits get this for free. Shared frameworks get close, and the remaining gap is exactly where users notice.

**The platform's conventions matter to your users.** Mac users expect menus, keyboard shortcuts, multiple windows and drag and drop to work the way they do everywhere else. An app that ignores them feels like a web page in a window, and people who use it all day stop forgiving that quickly.

**You want new platform features on day one.** Widgets, Live Activities, App Intents, new privacy permissions. Native code can adopt them when Apple or Google ships them. A shared framework adopts them when the framework does.

## When is one shared codebase the better trade?

When the app is mostly forms, lists and content behind an API. A booking app, a customer portal on the phone, an internal tool for a field team: the screens are standard, the logic lives on the server, and both platforms need the same features at the same time.

In that case writing every screen twice buys very little. One codebase means one implementation of each screen, one set of bugs and one place to make a change, and the budget goes into the parts users actually notice.

It does not make the platforms disappear. Code signing, store listings, review, push notification setup, permission prompts and testing on real devices still happen once per platform, whatever the code looks like.

## What does each choice cost to maintain?

The build is the smaller part of an app's cost. iOS and Android each ship a major release every year, and each one can change permissions, retire an interface or alter how something renders. Google Play also requires updates to target a recent Android version, a bar it raises every year, and apps that fall too far behind stop being offered to new users on newer phones.

| | Native per platform | One shared codebase |
| --- | --- | --- |
| Interface code | Written per platform | Written once |
| New OS features | Available on release | When the framework adds them |
| Look and feel | Exactly the platform's | Close, with gaps |
| Things to upgrade | Each platform's SDK | Each SDK plus the framework |
| Best for | Hardware, polish, daily use | Forms, lists, content |

The shared codebase saves interface work and adds a third moving part: the framework itself, with its own release cycle and its own breaking changes. Native doubles the interface work and keeps each app on a single vendor's roadmap. Neither is free.

## Where does the back end fit in?

In the same place either way. The app should be a client of the same API as your website and admin panel, with the business rules on the server. That is what makes two native apps affordable: each one is an interface over shared logic, not a second copy of the product.

It also keeps the decision reversible. An app that starts on a shared codebase and outgrows it can be rewritten natively without touching accounts, payments or data, because none of those live in the app.

## How do we decide on a real project?

1. List every feature that touches hardware, the operating system or background work. If that list is long, native is likely.
2. Decide which platform has to launch first and which can follow. Launching both on the same day is rarely necessary.
3. Price both options in writing, including a year of maintenance, before any code exists.
4. Write the reason for the choice in the project's README, so whoever maintains the app in three years knows why it is built the way it is.

Sometimes step one shows that the app does not need the device at all. Then the cheapest app is a fast website, which is the subject of [the companion post](/blog/do-you-need-an-app). And when the answer is an app, [this is how we build them](/app-development).

---

Published by Vuewer. Websites, web applications and native apps, shipped to production.
Canonical version: https://vuewer.com/blog/native-or-cross-platform