A published Kotlin app
A Compose-based app live on Google Play under your developer account, with store listing, screenshots and the Data safety declaration completed.
Service · Mobile
Commission a native Android app written in Kotlin and Jetpack Compose, built by our team and released under your own Google Play developer account. We carry the brief through to a staged production rollout, then hand over the repository, CI pipeline and upload key.
Kotlin and Compose only, no wrappers
Device matrix agreed before build
Play Console releases run by us
Deliverables
A Compose-based app live on Google Play under your developer account, with store listing, screenshots and the Data safety declaration completed.
Feature modules, a version catalogue and convention plugins, so later teams can add screens without lengthening every build.
Room for local persistence, a repository layer exposing Kotlin Flow, and sync jobs scheduled through WorkManager with sensible retry rules.
CI that builds signed app bundles, runs unit and Compose UI tests, and pushes to internal, closed and production tracks on approval.
Crash reporting and Android vitals monitoring set up before launch, with startup time and ANR rate recorded as the reference point.
Early decisions
We set minSdk from your audience’s real device mix rather than habit, because each older version adds testing cost and API workarounds.
For an existing app we decide which View-based screens get rewritten and which stay, joined through interop until there is a reason to move them.
Hilt or Koin is chosen once, at the start, and applied uniformly so ViewModels and workers are constructed the same way everywhere.
Each sync, upload or reminder is classed as WorkManager work, a typed foreground service or an exact alarm, according to current platform restrictions.
Play App Signing is enabled, and the upload key is generated, stored and documented under your organisation, never a developer’s laptop.
Engagement
We read your analytics or market data to fix minSdk, screen classes, languages and the specific handsets we will test on.
One thin vertical slice, from API call through Room cache to a Compose screen, proves the module layout before features multiply.
Every merged change reaches the internal testing track, so your stakeholders install real builds from Play rather than side-loaded files.
Release begins at a small percentage while we watch crash-free users and ANRs, widening only when vitals hold steady.
Fit
Markets where Android holds most of the installed base justify an app tuned for that platform first, including low-memory devices.
Widgets, foreground services, NFC, Bluetooth LE, work profiles or Android Auto all sit closer to the metal than shared frameworks reach comfortably.
When iOS is handled natively elsewhere, a matching native Android build keeps both apps idiomatic and independently releasable.
Alternatives
If iOS and Android must launch together with identical features, a shared-code approach is usually cheaper to build and maintain.
Open registerTeams fluent in TypeScript and React can often reuse skills and some logic by building in React Native instead.
Open registerAn installable progressive web app can validate the idea and reach Android users without Play review or a native codebase.
Open registerAndroid behaviour varies with manufacturer battery managers, screen cut-outs, RAM and OS version. Picking the handsets up front turns “works on my emulator” into a concrete contract: these phones, these versions, these languages.
The list comes from your analytics where they exist, or from market share data for your launch countries when they do not. It changes the design too, since a layout that suits a flagship can crowd a compact screen.
A Kotlin app calls platform APIs directly, so features such as home-screen widgets, quick settings tiles, background location or companion device pairing need no bridge or plugin. Updates to Jetpack libraries arrive the day Google ships them.
The trade-off is that iOS needs its own build. We say so plainly during scoping, and point to a shared-code route when parity matters more than platform depth.
Recent Android releases restrict what an app may do when it is not visible. We map each background task to the mechanism the platform permits, add constraints such as unmetered network or charging, and surface progress so users know when a sync is pending.
At the end you receive the repository, the CI configuration, a runbook for cutting a release, and a short architecture note explaining module boundaries. Any engineer familiar with modern Android should be able to ship the next version without us.
FAQ
Yes. The app is published under your developer account from day one, the repository lives in your organisation, and the upload key is stored where your team controls it.
We can. We begin with a build-and-audit pass covering Gradle health, target API compliance, crash clusters and test coverage, then agree what to fix before adding features.
We raise targetSdk as part of the build, test the behaviour changes each level introduces, and leave a note on the next deadline so updates are not blocked later.
We include at least one low-RAM handset in the agreed test set, and profile cold start and memory there, because that is where leaks and oversized images surface first.
Related services
A native Swift app built to the same API contract and analytics plan, so both platforms report comparable numbers.
Open registerEndpoints shaped around mobile needs: pagination, delta sync, idempotent writes and versioning that tolerates old app builds.
Open registerStructured test passes across manufacturer skins and Android versions before each rollout percentage increases.
Open registerHiring
Primary sources
Dated official documentation, standards, and research that support the factual claims on this page.
Google’s recommended layering for UI, domain and data in Android apps.
The yearly targetSdk deadlines that new apps and updates must meet.
How to read this page
Scope, cost and timeline figures are planning guidance until confirmed in a written proposal. Diagrams and screens are illustrations, not client deliverables, and source-code rights and handover follow the signed agreement. See the delivery process and the full disclaimer.
Next decision
Define outcomes, constraints, evidence, rights and handover before delivery begins.
Commercial rights, repositories, environments, documentation, acceptance and handover remain contract-defined.