When our mobile team started looking seriously at Kotlin Multiplatform, we had a people problem on our hands, not a technology one.
We had two native teams, iOS and Android, building the same business logic twice. The same data calls, the same validation rules, the same utilities, implemented separately, tested separately, and occasionally drifting apart in ways that were subtle enough to miss until a client noticed. Every time the requirements changed, we made the same update in two languages across two codebases just to keep parity.
KMP gave us a way out of that.
What we actually shared
Our first focus was two key areas where we could add consistency and predictability. The first was data processing: building shared logic to generate summary reports from repetitive data transformations. The second was network handling: a shared front-end on our APIs that kept retry logic and error handling consistent, regardless of which platform was making the call.
The trick is to keep the scope small. KMP works best when you’re sharing logic that is genuinely platform-agnostic. Threading strategies in particular deserve caution. Anyone who’s been there knows that getting clever with concurrency across platform boundaries is exactly the kind of thing that produces hard-to-diagnose bugs.
Our migration was partial and deliberate. We didn’t try to share everything at once. We identified the business logic that was most duplicated and most stable, extracted it into a shared KMP module, and let both teams integrate it incrementally.
It made the right problems easier to solve, even if it didn’t solve all of them.
The skepticism
Not everyone on the team was immediately on board. For the iOS developers in particular, the ask was a real one: learn Kotlin, a language they hadn’t been hired to write, in order to contribute to a shared codebase that was built around Android’s primary language. That’s a fair concern and we took it seriously.
In practice it went better than expected. Kotlin and Swift are remarkably similar in design. Both are modern, expressive, null-safe languages that share a lot of the same patterns and idioms. I’ve taught multiple Swift developers to work in Kotlin and not one had a real technical issue picking it up. There are even a few places where Kotlin pulled ahead of Swift — the flexibility of when compared to switch being a favorite example — but that’s a conversation for another post.
The resulting shared module reduced the surface area for cross-platform inconsistencies, and the unit test coverage on shared logic actually improved because we only had to write it once and we knew both platforms were running exactly the same code.
Unlike other cross-platform tools, KMP is built from the ground up for mobile developers. Once the iOS team started working in it, that became obvious pretty quickly.
Why it was a good decision for the business too
Kotlin Multiplatform lets you write shared Kotlin code that compiles to native binaries on each target platform. On iOS it compiles to a native binary. On Android it compiles to JVM bytecode. There is no intermediate interpreter, no bridge layer, no runtime sitting between your shared code and the platform it’s running on. KMP doesn’t ask you to abandon your existing native codebase. You introduce it where it makes sense, layer by layer, and the rest of your native code works just the way it used to.
Upper management was initially worried that KMP didn’t have enough momentum to be worth the investment. The answer has gotten clearer since then. KMP usage more than doubled among multiplatform developers in a single year, rising from 7% in 2024 to 18% in 2025. At Google I/O 2024, Google announced official support for using KMP to share business logic between Android and iOS. JetBrains has been a reliable steward of developer tooling for over twenty years, and with Google now formally behind the technology, the risk profile looks very different than it did even two years ago.
The ecosystem is still maturing, and the library coverage isn’t as broad as some alternatives yet. But for a native mobile team that wants to reduce duplication without giving up the performance, platform integration, and developer experience they’ve built expertise around, KMP is the most natural fit on the market right now.
Dowell Dev 