Native Android

Android app development services for the phones people really own

Kotlin apps built for the full spread of Android hardware: small screens, old OS versions, aggressive battery savers and patchy networks. Tested on real devices and released in stages through Google Play.

  • Kotlin and Jetpack Compose
  • Tested on real devices
  • Staged Play Store rollouts
What is included
  • Kotlin and Jetpack Compose UI
  • Architecture that scales
  • Local data with Room
  • Reliable background work
  • Device and hardware features
  • Play Store release management
Get a free quote Reply within one business day. NDA on request.
The problem

Why Android apps misbehave in the wild

An Android app has to run on thousands of device models, from last month's flagship to a budget phone with little memory and a manufacturer skin that closes background apps on its own schedule. Most Android complaints we hear come from that gap: it worked on the developer's phone.

We build native Android apps in Kotlin for businesses whose users are mostly on Android, whose product depends on hardware or background work, or who already have an Android codebase that needs a capable team. If you need iPhone as well, we can pair this with native iOS development or talk through whether a shared codebase would serve you better. The second option is often cheaper, and we will say so.

  • Crashes you cannot reproduce

    Reviews mention freezes and crashes on phones nobody in the office owns. Without device-level crash data, the team is guessing at fixes and shipping them blind.

  • Background jobs that silently stop

    Sync, reminders or location tracking work for a day, then the system or the phone maker's battery manager shuts them down. Users think the app is broken.

  • Play Console warnings pile up

    Emails about target API level, the data safety form or a permission declaration arrive with deadlines, and nobody on the team is sure what they require.

  • A Java codebase nobody wants to touch

    The app was written years ago with Activities, AsyncTask and XML layouts. Every change is risky, new hires avoid it and a full rewrite is not in the budget.

What we do

What our Android team delivers

We write modern Kotlin on Jetpack libraries and plan for the awkward parts of Android before they reach your reviews.

Kotlin and Jetpack Compose UI

Declarative screens in Compose with Material theming, adaptive layouts for phones, foldables and tablets, and interoperability with existing XML views where a rewrite is not justified.

Architecture that scales

ViewModels, coroutines and Flow, a repository layer and Hilt for dependency injection, split into modules so build times and teams can both grow.

Local data with Room

Typed SQLite access through Room with tested schema migrations, so an update never wipes a user's saved work, plus DataStore for settings.

Reliable background work

WorkManager for deferrable sync and uploads, foreground services where the user must see ongoing work, and alarms only when exact timing is truly needed.

Device and hardware features

Camera, Bluetooth Low Energy, NFC, GPS, biometrics and sensors, with runtime permission flows that explain the request before the system dialog appears.

Play Store release management

App bundles, Play App Signing, internal, closed and open testing tracks, staged production rollouts and the policy forms Google asks for.

Typical projects

Android work clients bring us

01

A hardware companion app

An app that pairs with a Bluetooth device, scanner or sensor, keeps the connection alive in the background and uploads readings when a network is available.

02

Apps for dedicated devices

Kiosk, point-of-sale or warehouse software on managed Android tablets and handhelds, locked to one task and updated outside the public store when needed.

03

Java to Kotlin modernization

Gradual conversion of an older app: Kotlin file by file, Compose screen by screen, coroutines replacing callbacks, with releases continuing throughout.

04

The Android half of an iOS product

Your iPhone app is live and Android users keep asking. We build the Android version against the same API, following Material conventions instead of copying iOS screens.

In depth

Building for Android as it really is

Fragmentation is a testing problem

You cannot test on every Android phone, so we choose a device matrix on purpose. It usually covers the oldest OS version you agree to support, a small low-memory phone, a current Samsung and Pixel, one device from a maker with aggressive battery management, and a tablet or foldable if layout matters. Emulators handle OS versions cheaply. Physical phones and a cloud device lab catch what emulators miss: camera quirks, keyboard overlap, font scaling and vendor permission screens. Where you set the minimum SDK is a business decision. Each older version adds users and adds testing, and we look at the version spread in your market with you before you choose.

Background work has rules now

Android restricts what an app may do when it is not on screen. Doze and app standby delay network access and jobs, starting a service from the background is blocked in most cases, and foreground services must declare a type and show a notification. So we sort every background need into one of three groups. Deferrable work such as sync or uploads goes to WorkManager with constraints for network and battery. Work the user is actively aware of, like turn-by-turn directions or a workout, runs as a foreground service. Time-critical triggers arrive as high-priority push messages. Anything that only works by fighting the system gets redesigned, because it will fail on real phones.

Compose, views and old code

New screens are written in Jetpack Compose. It is less code, easier to test and the direction Google is investing in. Existing XML screens do not have to be thrown away, since Compose and views can live in the same app and even the same screen. For older Java apps we move in steps: Kotlin first, then coroutines, then Compose where a screen is being changed anyway.

Getting through Google Play

A release is an Android App Bundle signed through Play App Signing. It moves from the internal testing track to closed testing with your own testers, then to production as a staged rollout that starts with a small share of users. We watch crash and ANR rates in Android vitals and halt the rollout if they climb. Before that, the Play Console needs an accurate data safety form, a privacy policy, content rating answers and declarations for sensitive permissions such as background location. Newer developer accounts may also have to complete a closed test before production access is granted, so we open the account and start that clock early. Digital goods sold in the app go through Google Play Billing, and we cover the server side of that under mobile app API integration.

Process

Our Android delivery steps

  1. 1

    Requirements and device targets

    We agree features, the minimum Android version and the device matrix, then send a scope and free quote that reflect that testing effort.

  2. 2

    Design to Material conventions

    Screens are designed for Android navigation, system back, dynamic text sizes and different screen widths, then approved as a clickable prototype.

  3. 3

    Kotlin development

    Features are built in modules with code review and unit tests. Internal testing builds reach your testers through the Play Console from the first sprint.

  4. 4

    Matrix testing

    QA runs each release candidate across the agreed phones and OS versions, including battery saver, poor network and interrupted background work.

  5. 5

    Staged rollout

    Production release starts with a small percentage of users. We track Android vitals and reviews, then widen the rollout or ship a fix.

Deliverables

Delivered with every Android app

  • A Kotlin codebase organized into clear modules
  • A documented device matrix and test results
  • Play Console set up under your developer account
  • Tested database migrations for future updates
  • Crash and ANR monitoring from the first release
FAQ

Android development questions answered

Kotlin or Java for a new Android app?
Kotlin. Google recommends it for Android, Jetpack libraries are designed around it and its null safety prevents a whole class of crashes. Kotlin and Java can share one project, so an existing Java app can be converted gradually without stopping releases.
Which Android versions should our app support?
It depends on your audience. Supporting older versions reaches more users in price-sensitive markets and adds testing work. We look at the version distribution for your target countries and any existing analytics, then recommend a minimum that covers nearly all of your users.
How do you test across so many devices?
With an agreed device matrix. Emulators cover OS versions, physical phones cover the brands your users carry, and a cloud device lab fills the gaps. After launch, Crashlytics and Android vitals show which models have problems so the matrix can be adjusted.
Why does our app stop syncing in the background?
Usually because the work was built in a way Android no longer allows, or a manufacturer battery saver is closing the app. We move sync to WorkManager, use push messages to wake the app when it matters, and guide users through battery settings only as a last resort.
Can you publish the app under our own Google Play account?
Yes, and we recommend it. You register the developer account, invite us with release permissions and keep ownership of the listing, the signing configuration and the reviews. We can walk you through the account verification that Google asks for before publishing.
Can the app be distributed outside Google Play?
Yes. Android allows direct APK installs and private distribution through device management tools, which suits internal and kiosk apps. You lose automatic store updates unless a management tool handles them, so we plan the update path up front.
What happens after launch when Google changes its requirements?
Google raises the required target API level on a regular schedule and updates its policies. Our app maintenance plans cover those updates along with dependency upgrades and crash fixes, so the app stays publishable.
Start a project

Talk to an Android developer

Tell us about the app, the devices it has to run on and any Play Console problems you are facing. We reply within one business day with a plan and a free quote.

  • Free consultation and quote
  • NDA on request
  • You own the source code
  • Reply within one business day
Add budget and timeline optional, helps us quote faster

This form is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.