Android / Kotlin: market

Vacancy

an open job that cleared the quality gate and lists at least two technologies

Observed candidate

a candidate whose stack contains this technology; an aggregate — not a single record leaves the perimeter

Matchable candidate

not counted yet

Window

jobs open at the moment the snapshot was built

Junior market is moderate — banks/fintech regularly hire after courses. The Junior → Middle jump — Kotlin coroutines + Compose + Clean Architecture + one DI (Hilt). Senior owns a feature module + mentor. Lead Android — architectural decisions + SDK for other teams. Career flow: Junior → Middle → Senior → either Tech Lead (management), Staff Android Engineer (deep technical), or Mobile Architect (cross-platform — Android + iOS + Compose Multiplatform).

Top 5: kotlin, java, jetpack compose, ci/cd, rest. Kotlin — must (official language since 2019, 95%+ of new projects). Java only in legacy banking. Jetpack Compose — modern declarative UI framework, dominator of new projects 2024–2026, gradually replaces XML layouts. XML layouts — legacy in existing codebases (mandatory for maintenance). Kotlin Coroutines + Flow — must for async. Architecture: MVI (trendy 2024+), MVVM (mainstream), Clean Architecture for large apps. Hilt (DI — Dagger-based, dominator). Room (SQLite ORM). Retrofit + OkHttp for REST API. Kotlin Serialization (modern) or Moshi/Gson. Coil (modern image loading) or Glide. Navigation Component or Compose Navigation. Firebase — Crashlytics + Analytics + Remote Config + Cloud Messaging + Firestore. Testing: JUnit 5 + Mockk + Espresso (UI) + Compose Testing + Roborazzi (screenshot testing). Gradle Kotlin DSL — modern build. Knowledge of Android internals (Activity/Fragment lifecycle, Process death, Doze mode) — Senior must.

Kotlin right away — that's the lock in 2026. Java was Android's official language only until 2019 (Google announced Kotlin-first). All new projects are in Kotlin; legacy is in Java existing codebases. Kotlin advantages: null-safety (NullPointerException sharply reduced), data classes, sealed classes for algebraic types, extension functions, named/default arguments, coroutines (cleaner async than RxJava). Junior should learn ONLY Kotlin from the very start. However, Java basics (collections, generics, OOP) are useful for understanding JVM bytecode and legacy maintenance. Strategy: learn Kotlin as primary, pick up Java basics in parallel (if you land in a legacy project — you'll have to read Java).

Jetpack Compose — modern declarative UI framework (Google, stable since 2021). Reactive approach, less boilerplate than XML, better for complex UI with animations. Dominator of new projects 2024–2026. Gradually replaces XML. XML layouts + View system — legacy approach since 2008 (from the first Android). Existing codebases (95%+ of production apps at banks/large product companies) are still on XML. Mandatory to know for maintenance + integration (Compose can host XML views and vice versa). Strategy: Compose first for new projects (2024+ — the industry is moving there), XML mandatory to understand at the level of "read someone else's code + add a feature to legacy". Junior starts with Compose, but pick up XML basics quickly (1-2 weeks) — to understand existing production apps.

Yes, 39% of Android jobs are full-remote or hybrid. Mobile development by nature doesn't require physical presence (tests on simulators + Firebase Test Lab for real devices). Russian product companies — hybrid or remote after probation. Banks (Sber/Alfa) — more often office due to compliance. Relocant hubs for Russian-speaking Android: Dubai, Cyprus, Lisbon, Tbilisi, Bali, Serbia (Belgrade). English — must for international remote with a premium +25-40%.

Android Native (this page) — native development in Kotlin/Java for Android only. Advantages: best performance, full access to platform APIs (camera/GPS/Bluetooth/NFC via native SDKs), native UX (Material Design 3). Downsides: codebase duplication for iOS. Flutter (Dart) — cross-platform from Google. One codebase for iOS + Android. Dominator in startups + CIS thanks to development speed. Senior Flutter ≈ Senior Native. React Native (JavaScript) — cross-platform from Meta. Used by international startups. See React (canonical redirect points there). Strategy: Native Android — if you work at a bank/large product company (performance-critical apps); Flutter — if a startup with fast iteration; React Native — if you already know React. Career switch Android Native → Flutter in 2-3 months (Dart is similar to Kotlin/TS).

Roadmap: 1) Kotlin — official documentation kotlinlang.org + book "Kotlin in Action" Jemerov. Master OOP in Kotlin + null safety + coroutines basics. 2) Java basics (1-2 weeks) — for legacy + JVM understanding. 3) Android Fundamentals — Activity/Fragment lifecycle, Process death, Intent system. Google's Android Developer Codelabs (free). 4) Jetpack Compose — Compose Pathway (Google free tutorial) + Compose Cookbook. Master declarative UI patterns. 5) Coroutines + Flow for async — Kotlin Coroutines official guide. 6) Architecture: MVVM or MVI + Clean Architecture. Book "Android Application Development with Kotlin" Wickham. 7) Hilt (DI) + Room (DB) + Retrofit (REST). 8) Firebase basics. 9) JUnit + Mockk + Compose Testing. 10) Pet project: one full-fledged Android app (TODO/notes/weather with REST API + auth + Firebase Analytics), published on Google Play. Books: "Head First Android Development" Sierra, "Kotlin in Action" Jemerov. Time to Junior — 8-12 months full-time.

537 active open Android positions — the largest mobile segment in CIS. Geography: Russia / Ukraine / Poland. The real market is broader thanks to the international remote segment (Toptal + Y Combinator startups). Time to close a Senior Android role — 3-6 weeks.

A Senior Android owns the full mobile development cycle. Kotlin mastery: coroutines deep (StateFlow/SharedFlow vs LiveData, structured concurrency, dispatchers), generics with variance, sealed classes for state modelling, extension functions, DSL design (like Anko/Compose). Jetpack Compose: deep understanding of Composition phases, smart recomposition (remember/derivedStateOf), CompositionLocal, side-effects (LaunchedEffect/DisposableEffect/produceState), custom layouts via Layout API, animations + transitions, performance (Modifier order matters, stable parameters). Architecture: Clean Architecture mastery (feature modules, use-cases, repository pattern), MVI with unidirectional data flow, navigation strategies (single-activity vs multi-activity). Performance: profiling via Android Profiler (CPU/memory/network), startup time optimisation (Baseline Profiles + Startup Profiles), Compose performance (recomposition counter), memory leaks via LeakCanary. Build: Gradle Kotlin DSL mastery, modularisation strategies (feature modules + buildSrc + convention plugins), R8/ProGuard rules. Testing: 70%+ coverage, JUnit5 + Mockk + Truth + Espresso + Compose Testing + Roborazzi (screenshot regression). Soft: code review, mentoring, communication with designer (Material Design 3 / iOS UX patterns). English for Senior+ must — for EU relocation and the Toptal network.