Kotlin Multiplatform in production: what to share, what to keep native, how to test it
Here is a bug every product with two native codebases ships sooner or later: the same order total shows 19.99 on Android and 20.00 on iOS. One side rounds half-up, the other rounds half-even. Nobody wrote a wrong line of code, and the user still stops trusting the app.
Duplicated business logic drifts. Two teams read the same spec, make two reasonable choices, and the product now has two truths. Kotlin Multiplatform is the most direct fix for that drift on mobile: it has been stable since late 2023, Google supports it for sharing business logic, and in 2026 the question is no longer "is it ready" but "where exactly do you draw the line". This post is about that line, and about keeping the shared part honest with tests.
The architecture in one sentence
Share the rules and the data, keep the screens and the platform services native. Everything that decides what is true (validation, calculations, units, the API contract, caching) lives in one Kotlin module. Everything that decides how it looks and how it talks to the OS (UI, push, background work, secure storage) is written natively on each side.
What goes where
The boundary is not a matter of taste. For each piece, ask one question: if Android and iOS behaved differently here, would it be a bug or a feature? A bug means shared. A feature means native.
| Piece | Where | Why |
|---|---|---|
| Validation and calculation rules | Shared | A mismatch here is a correctness bug, not a style choice. One implementation, one set of tests. |
| Units, conversion, rounding | Shared | The exact bug from the intro. Formatting for the locale can stay native, the math cannot. |
| Network client, DTOs, mapping | Shared | Ktor plus kotlinx.serialization: one contract with the backend, one place to fix it when it changes. |
| Repositories and cache policy | Shared | "When is the data stale" is a business rule, not a platform detail. |
| Presentation state | Depends | Sharing it saves code but pushes Kotlin Flows into Swift. Decide with the iOS developers, not for them. |
| UI | Native | Compose on Android, SwiftUI on iOS by default. Compose Multiplatform for iOS is now stable, so shared UI is an option, but it is a product decision, not a default. |
| Tokens, keys, biometrics | Native, behind an interface | Keystore and Keychain give hardware-backed guarantees no common abstraction can. |
| Push, background work | Native | FCM and WorkManager on Android, APNs on iOS: lifecycles differ too much to hide. |
| Analytics, crash reporting | Interface shared, implementation native | Shared code can log an event without knowing which SDK sends it. |
Interfaces over expect/actual
KMP gives you expect/actual to reach platform APIs. It is great for tiny leaf functions such as a UUID or a clock. For anything with state or side effects I prefer a plain Kotlin interface in the shared module, implemented on each platform and injected through DI (Koin works in common code). The reason is testing: an interface can be replaced with a fake in commonTest, while an actual follows you into every test run.
Secure storage is the clearest case. The shared code needs "store this token" and "read this token". It does not need to know that on Android this is the Keystore and on iOS the Keychain. The interface keeps the secret on the platform side, where the platform's protection works, and keeps the shared code free of platform imports.
Testing shared code: the bug ships twice
The trade-off of KMP is simple: a bug in shared code reaches both platforms in the same release. That makes tests in the shared module the cheapest insurance you can buy. The practices that pay off:
- Table-driven tests for every rule. Each calculation gets a list of cases with the boundaries written out: zero, negative, the maximum the device can report, a unit switch in the middle of a session. Adding a case is one line, so people actually add them.
- Fakes, not mocks, in
commonTest. MockK runs on the JVM, not on Kotlin/Native. Hand-written fakes run everywhere and read like documentation. - Run shared tests on the JVM and on an iOS target in CI. Most pass the same way on both. The ones that do not are exactly the ones you needed.
- Contract tests for serialization. Real JSON samples from the backend, checked into the repo and parsed by the shared models. A renamed field fails a test, not a user's screen.
- Flows tested with Turbine. It works in common code, so state sequences get checked once for both apps.
- UI tests stay native. Compose UI tests or UIAutomator on Android, XCUITest on iOS: they cover the screens that consume the shared logic.
The process around the code
Shared code changes the review process more than the code itself. A change in the shared module should be reviewed by someone from each platform, because the Android developer does not see what the API looks like from Swift: a sealed class or a suspend function that reads well in Kotlin can be awkward on the other side. Static analysis (Detekt) belongs on the shared module too, so style arguments stay out of the review entirely.
And start sharing from the leaves: a new, isolated feature with clear rules is a far easier first candidate than an old screen with years of platform-specific fixes inside.
What I'd do again, and the mistakes to avoid
Would I pick KMP again for a new product with Android and iOS apps? Yes, for one reason: the rules that must be identical live in one place and are tested once. What I would repeat:
- share rules and data first, UI never by default;
- interfaces plus DI for platform services,
expect/actualonly for leaf functions; - tests in
commonTestfrom the first shared class, run on both targets.
The mistakes worth avoiding: designing the shared API only from the Android side and leaving the iOS developers to adapt; treating the boundary as obvious instead of writing it down (a table like the one above saves weeks of debate); and calling a feature "done" when only the Android app consumes it. Shared code is done when both apps ship it.
Kotlin Multiplatform в продакшене: что делать общим, что оставить нативным и как это тестировать
Вот баг, который рано или поздно выпускает любой продукт с двумя нативными кодовыми базами: сумма одного и того же заказа на Android — 19,99, а на iOS — 20,00. Одна сторона округляет «половину вверх», другая — «к чётному». Никто не написал ни одной ошибочной строки, а пользователь всё равно перестаёт доверять приложению.
Продублированная бизнес-логика расползается. Две команды читают одну спецификацию, делают два разумных выбора — и у продукта теперь две правды. Kotlin Multiplatform — самое прямое лекарство от этого расползания в мобильной разработке: он стабилен с конца 2023 года, Google поддерживает его для общей бизнес-логики, и в 2026 году вопрос уже не «готов ли он», а «где именно провести границу». Этот пост — про эту границу и про то, как тестами держать общую часть в честности.
Архитектура в одном предложении
Правила и данные — общие, экраны и платформенные сервисы — нативные. Всё, что решает, что является правдой (валидация, расчёты, единицы измерения, контракт с API, кеширование), живёт в одном Kotlin-модуле. Всё, что решает, как это выглядит и как общается с ОС (UI, пуши, фоновая работа, защищённое хранилище), пишется нативно на каждой стороне.
Что куда
Граница — не дело вкуса. Для каждого куска задайте один вопрос: если Android и iOS поведут себя здесь по-разному, это баг или фича? Баг — значит, общее. Фича — значит, нативное.
| Что | Где | Почему |
|---|---|---|
| Правила валидации и расчётов | Общее | Расхождение здесь — ошибка корректности, а не вопрос стиля. Одна реализация, один набор тестов. |
| Единицы, конвертация, округление | Общее | Ровно тот баг из начала поста. Форматирование под локаль может остаться нативным, математика — нет. |
| Сетевой клиент, DTO, маппинг | Общее | Ktor и kotlinx.serialization: один контракт с бэкендом и одно место, где его чинить, когда он меняется. |
| Репозитории и политика кеша | Общее | «Когда данные устарели» — бизнес-правило, а не деталь платформы. |
| Состояние экранов | Зависит | Общий код экономит строки, но тащит Kotlin Flow в Swift. Решать вместе с iOS-разработчиками, а не за них. |
| UI | Нативное | По умолчанию Compose на Android и SwiftUI на iOS. Compose Multiplatform для iOS уже стабилен, так что общий UI возможен, но это продуктовое решение, а не значение по умолчанию. |
| Токены, ключи, биометрия | Нативное, за интерфейсом | Keystore и Keychain дают аппаратные гарантии, которых не даст никакая общая абстракция. |
| Пуши, фоновая работа | Нативное | FCM и WorkManager на Android, APNs на iOS: жизненные циклы слишком разные, чтобы их прятать. |
| Аналитика, краш-репорты | Интерфейс общий, реализация нативная | Общий код может отправить событие, не зная, какой SDK его доставит. |
Интерфейсы вместо expect/actual
Для доступа к API платформы в KMP есть expect/actual. Это отлично подходит для крошечных листовых функций вроде UUID или часов. Для всего, где есть состояние или побочные эффекты, я предпочитаю обычный Kotlin-интерфейс в общем модуле: его реализуют на каждой платформе и внедряют через DI (Koin работает в common-коде). Причина — тесты: интерфейс в commonTest легко подменить фейком, а actual тянется за тобой в каждый прогон.
Самый наглядный пример — защищённое хранилище. Общему коду нужны «сохрани токен» и «прочитай токен». Ему не нужно знать, что на Android это Keystore, а на iOS — Keychain. Интерфейс оставляет секрет на стороне платформы, где работает её защита, а общий код — без платформенных импортов.
Тестирование общего кода: баг уезжает дважды
Компромисс KMP простой: баг в общем коде попадает на обе платформы в одном релизе. Поэтому тесты в общем модуле — самая дешёвая страховка, какую можно купить. Практики, которые окупаются:
- Табличные тесты на каждое правило. У каждого расчёта есть список случаев с явно выписанными границами: ноль, отрицательное значение, максимум, который может прислать устройство, смена единиц посреди сессии. Добавить случай — одна строка, поэтому их действительно добавляют.
- Фейки, а не моки, в
commonTest. MockK работает на JVM, но не на Kotlin/Native. Самописные фейки работают везде и читаются как документация. - Общие тесты в CI — и на JVM, и на iOS-таргете. Большинство проходят одинаково. Те, что нет, — именно те, которые были нужны.
- Контрактные тесты сериализации. Реальные примеры JSON от бэкенда лежат в репозитории и парсятся общими моделями. Переименованное поле роняет тест, а не экран у пользователя.
- Flow — через Turbine. Он работает в common-коде, так что последовательности состояний проверяются один раз для обоих приложений.
- UI-тесты остаются нативными. Compose UI-тесты или UIAutomator на Android, XCUITest на iOS: они покрывают экраны, которые используют общую логику.
Процесс вокруг кода
Общий код меняет ревью сильнее, чем сам код. Изменение в общем модуле стоит ревьюить человеку от каждой платформы: Android-разработчик не видит, как API выглядит из Swift. Sealed-класс или suspend-функция, которые красиво читаются в Kotlin, на другой стороне могут оказаться неудобными. Статический анализ (Detekt) тоже должен проверять общий модуль — тогда споры о стиле вообще уходят из ревью.
И начинать делать общее стоит с листьев: новая изолированная фича с понятными правилами — гораздо более простой первый кандидат, чем старый экран с годами платформенных правок внутри.
Что я сделал бы снова и каких ошибок избегать
Выбрал бы я KMP снова для нового продукта с приложениями на Android и iOS? Да, по одной причине: правила, которые обязаны совпадать, живут в одном месте и тестируются один раз. Что я бы повторил:
- сначала общими делать правила и данные, UI — никогда по умолчанию;
- интерфейсы и DI для платформенных сервисов,
expect/actual— только для листовых функций; - тесты в
commonTestс первого общего класса и прогон на обоих таргетах.
Ошибки, которых стоит избегать: проектировать общий API только со стороны Android и оставлять iOS-разработчикам подстраиваться; считать границу очевидной вместо того, чтобы её записать (таблица вроде той, что выше, экономит недели споров); называть фичу «готовой», когда её использует только Android-приложение. Общий код готов, когда его выпустили оба приложения.
— Dmitry