App development for iOS, Android, the web and large displays, guided by measurable goals and supported well beyond the store launch.
Kotlin Multiplatform | Anexia Digital Engineering

Kotlin Multiplatform for shared logic and native interfaces.
Between two entirely separate native apps and a fully shared codebase lies a third route that long went under the radar. Kotlin Multiplatform shares the business logic, exactly where duplicated work hurts most. The interface on iOS and Android stays as native as before.
When Kotlin Multiplatform is the right choice
Anexia Digital Engineering uses Kotlin Multiplatform for organisations that will not compromise on the quality of the user experience, yet do not want to pay for every calculation rule twice. Whether the approach pays off depends on where you start. Four situations make a particularly strong case for it.
Existing Kotlin Android app
The easiest way in. Existing code for networking, data and rules moves step by step into a shared module. Android users notice no change, and the iOS app builds on proven logic instead of starting over.
Experience comes first
Consumer apps in competitive markets such as banking, mobility or retail are measured against the best native apps. Native interfaces adopt Apple and Google updates on day one, Liquid Glass included.
Complex business logic
Tariff calculations, rule sets, configurators, medical assessments. The more of this logic an app contains, the more valuable it is to write and test it only once.
Step by step
No rebuild required. A single module such as the API client can come first, and if it works, the next one follows. Stop at any point and nothing is lost, because the apps remain ordinary native apps.
The idea behind Kotlin Multiplatform
Every app contains code that has nothing to do with the screen. It calculates prices, validates input, loads data from the server, stores it locally, buffers it when there is no connection and synchronises it later. With two native apps all of this exists twice, once in Swift and once in Kotlin. Two teams read the same specification and reach different results in edge cases.
Kotlin Multiplatform, KMP for short, tackles this problem at the root. The shared code is written once in Kotlin. For Android it compiles as usual, while for iOS the compiler produces a native framework that can be added to Xcode like any other library. From the iOS app's point of view, the shared part is simply one more module.
How mature Kotlin Multiplatform is
JetBrains declared Kotlin Multiplatform stable in November 2023. Since 2024 Google has officially supported the approach for sharing business logic between Android and iOS and has opened its own libraries, such as Room and DataStore, for it. What began as an experiment has become a technology you can build a product on.
Native or shared interface
When it comes to the interface, you have a choice. In the classic variant it stays fully native, with SwiftUI on iOS and Jetpack Compose on Android. Alternatively, Compose Multiplatform lets you share the interface as well, and its iOS support has been considered stable since May 2025. The two variants can be mixed, for example with shared views for standard screens and native views for everything that matters most.
What Kotlin Multiplatform shares and what it doesn't
The boundary between shared and platform-specific code is the most important architectural decision in the project. Share too little and there is no benefit, share too much and you create friction. Good candidates for sharing are data models and their serialisation, network access and error handling, and the local database with its cache. Business rules, calculations and validation belong there too, as do synchronisation for offline use, the state logic behind the views, analytics events and logging.
In the classic variant, the interface and navigation stay platform-specific, as do push setup, widgets, watch apps and deep system integration. For features that exist on both platforms but are accessed differently, the shared code defines an expectation and each platform supplies its own implementation. Biometric sign-in and secure storage are typical examples.
How large the shared portion ends up depends on the type of app. In an app with a lot of business logic and offline capability, it can account for more than half of the code. In an app that only displays content it is small, and the benefit is correspondingly modest.
One module, one team
Technology alone does not cut costs. Kotlin Multiplatform changes how teams work together, and the shared module needs clear ownership. What works is Android and iOS developers building it together and reviewing each other's changes. A model in which the Android team delivers and the iOS team merely consumes leads to frustration.
iOS developers do not need to master Kotlin, but they should be able to read it. Swift and Kotlin are very similar, so this usually takes a few weeks, and many discover along the way that they can contribute to the shared code. Since every change to shared logic affects both apps, a common release cadence is not a formality. Anexia Digital Engineering has been developing apps since 2008, with a team of more than 40 specialists in Austria and Germany.
How we work with Kotlin Multiplatform

In regulated industries, differences between platforms are not a cosmetic flaw. They are a risk.
Kotlin Multiplatform in existing apps
Many enquiries come from organisations that already run two native apps and want to reduce the duplicated effort. We move step by step, and both apps remain ready to ship throughout the transition.
- An analysis of both codebases as the starting point
- Backend access usually becomes the first shared module
- Android switches first, then iOS
- Both apps stay ready to ship at all times
- A decision after the pilot, based on facts
From pilot to shared logic
It starts with an analysis of both codebases. Where do the apps behave differently, where do recurring bugs appear on only one platform, and which parts change most often? The answers point to a candidate for the first shared module. We usually begin with backend access, because it is clearly delimited, easy to test and built in a similar way on both sides. The Android app switches over first, followed by the iOS app.
After this pilot you decide on the basis of facts. How much effort did it take, how did the iOS team respond, and how did build times and bug counts develop? If the verdict is positive, data storage and business logic follow. If not, you still have two working native apps and a decision grounded in experience rather than assumptions.
When other approaches fit better
To be frank, Kotlin Multiplatform is not the cheapest route to two apps. If the interface can look identical on both platforms and the budget is tight, Flutter app development or React Native development will get you there faster. For apps with little logic that mainly display content, the extra setup does not pay off. In that case classic native app development or a fully shared framework makes more sense.
The team question plays a part too. Without Kotlin experience in-house or at your provider, getting started is hard going, and iOS developers have to be willing to work with a module whose source code is written in another language. Our page on cross-platform app development compares all the options.
Kotlin Multiplatform costs compared
In terms of cost, the approach sits between the two poles. It takes more effort than a fully shared framework, because two interfaces are built. It is more economical than two separate native apps, because the logic is created only once, in development, testing and maintenance alike.
The advantage grows with the product's lifetime. In the first year, setting up the shared structure is the main cost. From the second year onwards, every change to business logic saves effort, because it happens in one place. That makes the model particularly attractive for long-lived products with a lot of business logic. Our page on app development costs sets out how the figures are calculated.
- 1,500+
- projects since 2006
- 40+
- specialists at Anexia Digital Engineering
- 400+
- people across the Anexia Group
- 2008
- the year Anexia started building apps
Common questions about Kotlin Multiplatform
Related topics
- App Development
- Ionic App Development
Ionic and Capacitor turn your web application into an app for iOS and Android, built on the knowledge your team already has.
- Progressive Web App
An app that arrives via a link, works offline and sends notifications. When a progressive web app is enough and when it is not.
- Dart Development
Apps, backends and tooling in Dart, plus code audits, modernisation and experienced engineers who work within your team and pass on what they know.
- Mobile App Development
React Native and Flutter for cross-platform plus native development with Swift and Kotlin - mobile applications for iOS and Android.
- UX/UI Engineering for B2B Software
Interaction concepts, prototyping in Figma, design systems, usability testing and accessibility to WCAG 2.1 for complex B2B software.
Long view. Share logic. Keep quality.
Tell us how much logic your apps contain and how your team is set up. In a no-obligation initial conversation we will assess whether a pilot makes sense, whether Kotlin Multiplatform pays off for your product and what the first step could look like. You get a sober assessment.

