Start typing to search this publication.
techcirkle
Open menu

Subscribe to techcirkle

Get new posts delivered straight to your inbox.

Kotlin Multiplatform Is the Answer Most Teams Should Have Picked

Most teams choosing cross-platform were solving business logic duplication, not UI duplication. KMP addresses the actual problem.

techcirkle
5 min read
Cover image for Kotlin Multiplatform Is the Answer Most Teams Should Have Picked
Software developer testing an Android smartphone application at a desk with a laptop
Software developer testing an Android smartphone application at a desk with a laptop

The native-versus-cross-platform argument has been running for a decade with a hidden assumption baked into it: that the thing you are trying to avoid duplicating is the user interface.

For most teams I talk to, that is not where the pain is.

Ask an engineer maintaining an Android and an iOS app what actually costs them. It is rarely "we built the settings screen twice." It is that a validation rule changed and got updated in one codebase and not the other. That the retry-and-backoff logic behaves differently on each platform because two people implemented it independently. That a pricing calculation has drifted, and nobody noticed until a customer did.

The duplication that hurts is business logic. And if that is the problem, a framework that unifies rendering is solving something adjacent to it while introducing an abstraction between you and the platform.

What KMP actually shares

Kotlin Multiplatform lets you share the layers underneath the UI while keeping both interfaces fully native — Compose on Android, SwiftUI on iOS.

In practice that means:

  • Domain logic — validation, pricing, business rules, state machines

  • Data layer — networking, serialisation, caching, persistence

  • Presentation state — view models and the state they expose, if you want to go that far

And it means you do not share the UI. Which, for most products, is correct — the UI is where platform conventions matter and where users notice when something feels foreign.

// commonMain — one implementation, both platforms
class SubscriptionPricer(private val rules: PricingRules) {
    fun quote(plan: Plan, seats: Int, region: Region): Quote {
        require(seats > 0) { "seats must be positive" }
        val base = rules.basePrice(plan, region)
        val discount = rules.volumeDiscount(seats)
        return Quote(
            net = base * seats * (1 - discount),
            currency = rules.currency(region),
            appliedDiscount = discount,
        )
    }
}

That function is written once and cannot drift. On the iOS side it arrives as a normal Swift type. No bridge, no serialisation boundary, no runtime.

The property that matters most

KMP compiles to native binaries on both platforms. There is no JavaScript runtime, no bridge, no rendering abstraction.

The practical consequence is that KMP is incrementally adoptable and incrementally reversible, which is unusual in this category.

You can start by sharing one module — say, your networking and models — while both apps stay otherwise untouched. If it does not work out, you delete the shared module and reimplement it twice. That is a bounded cost.

Compare that to a full cross-platform rewrite, where the decision is effectively irreversible for years. The asymmetry in risk here is large and underweighted in most evaluations.

Startup development team reviewing mobile application designs on screen
Startup development team reviewing mobile application designs on screen

Where the platform-specific escape hatch lives

The expect/actual mechanism handles things that genuinely differ, and it is worth showing because it is what makes the model workable rather than aspirational.

// commonMain
expect class SecureStore {
    suspend fun put(key: String, value: String)
    suspend fun get(key: String): String?
}

// androidMain
actual class SecureStore(private val context: Context) {
    private val prefs = EncryptedSharedPreferences.create(/* ... */)
    actual suspend fun put(key: String, value: String) { /* ... */ }
    actual suspend fun get(key: String): String? { /* ... */ }
}

// iosMain — Keychain, called directly, no wrapper layer
actual class SecureStore {
    actual suspend fun put(key: String, value: String) { /* Security framework */ }
    actual suspend fun get(key: String): String? { /* ... */ }
}

You are not fighting an abstraction that is trying to unify Keychain and EncryptedSharedPreferences into a lowest common denominator. You declare the contract and implement it properly on each side.

Honest costs

This is not free, and pretending otherwise does nobody any favours.

Your Android engineers become responsible for code that ships on iOS. That is a real change in how the team works, and it requires that someone on the iOS side is comfortable reviewing Kotlin. In practice this is the largest adoption cost and it is organisational rather than technical.

Build complexity increases. Multiplatform Gradle configuration is more involved than a single-target Android build, and CI needs to produce and test both artefacts.

Library availability is good but not universal. Networking, serialisation, database, and concurrency are well covered. Something niche may need an expect/actual wrapper you write yourself.

Debugging across the boundary is better than it was and still not as smooth as staying within one platform's tooling.

When it is the wrong call

If your app is genuinely UI-heavy with thin logic — a content reader, a simple catalogue browser — the shareable surface is small and the setup cost may not pay back.

If you have one platform and no plan for a second, do not pre-emptively adopt it. Structure the code well and adopt later if the second platform arrives; that is a cheap migration.

And if your team has no Kotlin experience at all, the learning curve compounds with the multiplatform curve. That is a fair reason to defer.

The decision in one line

If your duplication pain is business logic, KMP addresses it directly while preserving native UI. If your duplication pain is genuinely the UI, a full cross-platform framework is a more coherent answer — just be clear about which problem you actually have, because most teams answer this by instinct rather than by looking.


The full buyer-side guide — Android scope, cost ranges, Play compliance as an engineering workstream, engagement models, and the questions that expose a weak vendor — is here: Android App Development Services: What to Evaluate in 2026.

TechCirkle does mobile app development across Android, iOS and shared Kotlin.

Frequently Asked Questions

What does Kotlin Multiplatform actually share?

Domain logic, data layer (networking, serialisation, caching, persistence) and optionally presentation state. It deliberately does not share the UI, which stays native — Compose on Android and SwiftUI on iOS.

How is KMP different from React Native or Flutter?

KMP compiles to native binaries with no JavaScript runtime, bridge, or rendering abstraction. It shares the layers beneath the UI rather than unifying rendering, so platform conventions and performance characteristics stay intact.

Is Kotlin Multiplatform reversible if it does not work out?

Largely, yes. You can adopt one shared module at a time and, if it fails, delete it and reimplement twice. That bounded downside contrasts sharply with a full cross-platform rewrite, which is effectively irreversible for years.

How do you handle platform-specific APIs in KMP?

Through the expect/actual mechanism: declare the contract in common code and implement it properly on each platform — EncryptedSharedPreferences on Android, Keychain on iOS — without forcing a lowest-common-denominator abstraction.

What is the biggest cost of adopting KMP?

Organisational rather than technical. Android engineers become responsible for code that ships on iOS, which requires someone on the iOS side comfortable reviewing Kotlin. Build and CI complexity also increases.

When is Kotlin Multiplatform the wrong choice?

When the app is UI-heavy with thin logic, when you have one platform and no concrete plan for a second, or when the team has no Kotlin experience and would be climbing two learning curves simultaneously.

Subscribe to techcirkle