Skip to content
← All posts

Native or cross-platform: how we decide

Mobile and desktop apps 5 min read

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. And when the answer is an app, this is how we build them.

Questions people also ask

Is cross-platform cheaper than native?

Usually at the start, and rarely by half. The interface is written once, but signing, store review, push notifications, permissions and testing on real devices still happen per platform, and the shared framework brings upgrades of its own. Over a few years the gap narrows.

Can we start cross-platform and go native later?

Yes. If the business rules live in your API rather than in the app, going native means rewriting the app's interface, not rebuilding the product. Plan it as a rewrite of the client, because that is what it is.

Should a Mac app be built with Electron?

Only if it is essentially a web app that needs a dock icon. Electron ships its own copy of the Chromium browser engine, so even a small app is a large download, and it never quite behaves like the rest of macOS. Anything that touches cameras, files or the menu bar is better written in Swift.

Do both platforms need to launch on the same day?

Rarely. Launching where most of your users already are, and adding the second platform once the first one has real usage, costs less and shows you what the second version should do differently.

Who wrote this

Alexander (Sander) van Hooff

Alexander (Sander) van Hooff has been building software since 2015: websites, web applications in Laravel, and native apps for the phone and the desktop. Vuewer is his studio, run from the Alicante region of Spain for clients across Europe.

Work with Vuewer

Related reading

Mobile and desktop apps 4 min read

Do you need an app, or a fast website?

An app has to earn its place on the home screen and costs more every year it exists. Five questions that show when a fast website does the job instead.

Search, AEO and GEO 3 min read

SEO, AEO and GEO: what actually changed

Three acronyms, one shift: search engines now answer instead of link. What that changes about how pages should be written, and what it does not change at all.

Get in touch

We'd love to hear from you.

Do you have a question or need help with a website or web application? Whether you are starting from scratch, refining what you already have, or stuck on something complex.

Fill in the form and we'll get back to you as soon as possible.