Summary

We’re building a multi-module Kotlin codebase with an Android app (Jetpack Compose) and a shared Kotlin Multiplatform (KMP) data layer used by Android and iOS. The app must support a robust custom sync engine, modular features, strong separation of concerns (Clean Architecture), and high-quality test coverage.

Target platforms & modules

• Android (Kotlin) — UI with Jetpack Compose (Material Design).

• Kotlin Multiplatform (KMP) — shared data-layer modules consumed by Android and iOS.

• Modularity — dynamic feature modules / flavors for feature delivery and separation.

Tech Stack

• Language: Kotlin

• UI: Jetpack Compose (Material Design)

• Persistence: Room (type converters, composite entities, DAOs)

• DI: Koin

• Concurrency: Coroutines, Flow (StateFlow, SharedFlow)

• Networking/IO on shared layer: Ktor (abstracted, platform-agnostic streams / byte arrays)

• Serialization: kotlinx.serialization

• Compression & unpacking: Brotli, 7z (handled in sync flows)

• Testing: JUnit, Turbine, MockK / Mokkery

• Other: Android Navigation, file I/O abstraction (FileManager), Firebase integration

Architecture & design principles

• Clean Architecture (Use Cases → Data Sources → Shared Data Layer)

• SOLID principles across modules

• Separation of concerns

• Use cases encapsulate business rules and any platform-specific decisions.

• Data sources implement local (Room) and remote (Ktor) transport.

• FileManager handles platform-specific file I/O behind an interface.

• Dependency inversion — data sources expose platform-agnostic types to higher layers.

• Registry / Orchestration patterns for coordinated sync across tables/DAOs.

• Custom Sync Engine with clear separation between orchestration and transport

.

Sync engine features

• SyncRegistry & SyncOperations patterns to orchestrate per-table sync flows.

• Initial & Delta sync flows:

• Support compressed payloads (Brotli).

• Support archive decompression (7z) and streaming where appropriate.

• Transport abstraction — sync code should be decoupled from HTTP client details.

• Error handling — app-specific exceptions separate from transport/client exceptions.

• Resumable / idempotent operations where possible; consistent conflict handling policy.**

Persistence & data modelling

Room database with:

Entities and composite entities

Type converters for complex fields

Clear DAO layer with well-defined contracts for sync and use cases

Shared data layer types in KMP for cross-platform consistency

Data-mapping layer between platform models and shared models (mappers)

Concurrency & flows

Use Coroutines for async work

Use StateFlow for UI state streams

Use SharedFlow for events and one-off streams

Testing flows with Turbine

Testing & quality

Unit tests for use cases, data sources, and sync logic (JUnit)

Mocking with MockK or Mokkery

Flow testing with Turbine

Encourage TDD: write tests for use cases and data sources in isolation

Integration tests for critical sync flows and Room interactions (where feasible)

Responsibilities / Candidate expectations

Deliver production-quality features in Jetpack Compose and Room.

Build and maintain the shared KMP data modules and ensure clean APIs for platform code.

Design and implement sync orchestration (SyncRegistry/SyncOperations) and robust error handling.

Abstract platform specifics (file I/O / network) behind interfaces for KMP modules.

Write tests (unit + flow tests) and maintain high code quality.

Work in a multi-module repo with strict modular boundaries.

Integrate with Firebase where needed (auth, messaging, analytics).

Debug complex issues across Android + shared modules.

Must-have skills

**Hands-on experience with Jetpack Compose and Room.

• Strong Kotlin skills and familiarity with Coroutines and Flow (StateFlow/SharedFlow).

• Solid knowledge of Clean Architecture and SOLID principles.

• SQLite

• Experience working in multi-module Android/KMP projects or strong willingness to learn quickly.

• Experience writing unit tests and using mocking libraries (MockK/Mokkery).

• Comfortable with DI using Koin (or similar) and Android Navigation.

• Experience handling file I/O and streaming decompression in an app context.**

Nice-to-have

• Prior Kotlin Multiplatform experience (shared modules, expect/actual patterns).

• Experience with kotlinx.serialization and Ktor on KMP.

• Experience designing sync systems (delta/initial sync), compression handling (Brotli/7z).

• Familiarity with Firebase services (Auth, Cloud Messaging, Crashlytics).

• Experience with performance tuning (DB indices, paging, memory usage).