Plain source, for humans in a hurry and machines in general.
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?
- List every feature that touches hardware, the operating system or background work. If that list is long, native is likely.
- Decide which platform has to launch first and which can follow. Launching both on the same day is rarely necessary.
- Price both options in writing, including a year of maintenance, before any code exists.
- 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?
Can we start cross-platform and go native later?
Should a Mac app be built with Electron?
Do both platforms need to launch on the same day?
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 VuewerRelated reading
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.
Multilingual Laravel: translated routes done properly
Why /nl/pricing loses to /nl/tarieven, how to build translated slugs in Laravel, and the hreflang mistakes that quietly cost you the other languages.
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.