Skip to content
Dware

Mobile apps

Hire Android developers to build Kotlin apps that work on every device

Our Android developers build native apps in Kotlin and Jetpack Compose that run smoothly on cheap phones, flagships, tablets and foldables. They know Google Play's policies, testing tracks and review, so launch day goes to plan. Meet a vetted senior engineer in 48 hours.

  • Modern Kotlin and Jetpack Compose, tested across devices
  • Google Play policies and testing tracks handled for you
  • You own the code and the Play Console account

Overview

What Android developers do in a world of thousands of devices

Android runs on billions of devices made by hundreds of brands. That is its biggest strength and its hardest problem. Your app has to work on a budget phone with little memory, a large Samsung foldable, a Pixel tablet and a phone still on an Android version from several years ago. Some manufacturers also change how background work and notifications behave. A skilled Android developer plans for all of this from the start.

Modern Android apps are written in Kotlin, which Google treats as the main language for Android. The interface is built with Jetpack Compose, Google's declarative UI toolkit, and Material 3 design. Around it sit the Jetpack libraries: ViewModel for screen state, Room for the local database, WorkManager for background jobs and Navigation for moving between screens. Older apps use XML layouts and Java, and good Android developers are comfortable with both.

Google Play has its own rules. Apps must target a recent Android API level, fill in an accurate Data safety form and follow policies on permissions, payments and background location. New personal developer accounts must run a closed test with real testers before they can publish to production. Breaking a policy can get an update rejected or an app removed, so policy work is part of development, not an afterthought.

When you hire Android developers from Dware, you get engineers who handle all of it: architecture, Compose UI, Firebase, background work, testing on a real device matrix and releases through the Play Console. You get senior code review on every change and regular updates on progress.

What we build

Android app development services

Our Android developers cover new builds, rescue work on existing apps and the extra form factors many teams forget.

  • Native Android apps in Kotlin

    We build new apps in Kotlin with Jetpack Compose and Material 3. The code follows Google's recommended app architecture, so it is easy for any Android developer to pick up later.

  • Java and XML to Kotlin and Compose migration

    We convert older apps one module or screen at a time. Compose and XML views run side by side, so new features keep shipping while the codebase is modernised.

  • Background work, sync and offline mode

    We use WorkManager, foreground services and a local Room database so data syncs reliably, even after the app is closed or the phone restarts. We test against Doze mode and battery savers on popular brands.

  • Firebase and push notifications

    We set up Firebase Cloud Messaging, Crashlytics, Analytics and Remote Config. Notifications use proper channels and the Android 13 notification permission, so users stay in control.

  • In-app purchases with Google Play Billing

    We build subscriptions and one-time purchases with the Play Billing Library and verify purchases on your server with Real-time developer notifications. Access stays correct when users cancel, pause or change plans.

  • Tablets, foldables and Chromebooks

    We build adaptive layouts with window size classes, so screens rearrange on large displays and folding phones. Google increasingly expects apps to support large screens, and good tablet support can improve how your app is shown on Play.

  • Wear OS apps and tiles

    We build Wear OS apps with Compose for Wear OS, plus tiles and complications for quick glances. They sync with the phone app through the Data Layer API or work on their own.

  • Performance and stability fixes

    We read Android vitals and Crashlytics reports, fix the worst crashes and ANRs first and speed up startup with Baseline Profiles. Google Play can show warnings and reduce visibility for apps with poor vitals.

Our process

How we build your Android app, step by step

Android projects follow a clear path from idea to Google Play. Each step includes work that is specific to Android's devices, rules and tools.

  1. 1

    Discovery and device strategy

    We start with a free call about your users, where they live and what phones they own. That decides your minimum Android version and your test device list, because a budget-phone market needs different choices than a premium one. We check Google Play policies that may affect you, such as background location, SMS or payment rules. You get a written scope and a fixed quote.

    What you get

    • Scope and feature list
    • Minimum SDK and device list
    • Policy risk notes
    • Fixed quote
  2. 2

    Design with Material 3

    We map flows with Material 3 patterns, such as navigation bars, bottom sheets and predictive back. Layouts are planned for phones, tablets and foldables using window size classes. We design for edge-to-edge screens, dark theme and large font sizes. If your designer works in Figma, we turn their designs into a Compose theme and components.

    What you get

    • User flows and screen map
    • Compose design system
    • Large-screen layouts
  3. 3

    Architecture and project setup

    We set up a multi-module Gradle project with a version catalog so builds stay fast as the app grows. Screens use ViewModels with Kotlin coroutines and Flow, Hilt handles dependency injection and Room or DataStore store data on the device. Networking uses Retrofit or Ktor with clear error handling for slow and offline connections. The app is registered in your own Play Console account with Play App Signing switched on.

    What you get

    • Gradle project in your repo
    • Architecture document
    • Play Console and signing set up
  4. 4

    Build in sprints with internal testing

    We build in one- or two-week sprints. Each sprint's build goes to the Play Console internal testing track, which lets up to 100 testers install it from Google Play within minutes. Firebase App Distribution is an option for testers outside Play. Every pull request gets senior code review and runs automated checks before merging.

    What you get

    • Internal test build every sprint
    • Sprint demo
    • Reviewed pull requests
  5. 5

    Testing across the device matrix

    We write unit tests for ViewModels and business logic and Compose UI tests for key flows. We run the app on real devices from several brands, including a low-memory phone, a tablet and a foldable, and on emulators for older Android versions. Firebase Test Lab can run the suite on many more device models at once. We test process death, rotation, low battery modes and poor networks, which is where Android bugs like to hide.

    What you get

    • Automated test suite
    • Device test report
    • Crashlytics set up
  6. 6

    Closed testing and Google Play release

    We complete the Play listing, content rating questionnaire and Data safety form, then ship an Android App Bundle. New personal developer accounts must run a closed test with at least 12 testers for 14 days before production access, and we plan that into the schedule. We release with a staged rollout, starting with a small share of users and widening it while we watch crash rates. If anything looks wrong, we halt the rollout from the Play Console.

    What you get

    • Store listing and Data safety form
    • Closed test managed
    • Staged production rollout
  7. 7

    Support and yearly Android updates

    After launch we watch Android vitals, Crashlytics and Play reviews and ship fixes quickly. Each year Google releases a new Android version and raises the target API level that updates must meet. We test on the Android betas, adapt to new behaviour changes and update the target SDK before the deadline. Your app keeps publishing without last-minute surprises.

    What you get

    • Vitals and crash monitoring
    • Target SDK updates
    • Fix and feature releases

Want this process for your project? Tell us what you're building and get a free, fixed quote.

Get a free quote

Technical expertise

Android development detail that keeps your app healthy

These are the areas where Android apps most often go wrong, and how our developers handle them.

Fragmentation without the headaches

We set a sensible minimum SDK, use AndroidX libraries that smooth over version differences and gate newer APIs behind version checks. Each new Android release changes rules, such as runtime notification permission, required foreground service types and edge-to-edge display. Large screens matter more now too, so apps should not lock themselves to portrait on tablets. We follow these changes so your app behaves on old and new devices alike.

Background work that actually runs

Android limits background work to save battery, and some manufacturers add their own stricter limits. We use WorkManager for deferrable jobs, foreground services with the right declared type for ongoing work and exact alarms only when the use case qualifies. We avoid background location unless your app truly needs it, because Google Play asks you to justify it in a declaration. The result is sync and reminders that work without draining the battery.

Google Play policy and review

Google Play reviews new apps and updates against its Developer Program Policies. Apps must use Google Play Billing for digital goods in most cases, declare sensitive permissions and keep the Data safety form accurate, including for SDKs you include. Apps with user accounts must offer account deletion in the app and on the web. We check these points before every release, so updates go out on time.

Speed and stability

Users judge an app in its first seconds. We add Baseline Profiles to speed up startup and scrolling, shrink the app with R8 and keep heavy work off the main thread to avoid ANRs. We track crash-free users and ANR rates in Android vitals, which Google uses when ranking apps. Compose recomposition is profiled, so lists stay smooth on cheaper phones.

Security and integrity

We store secrets in the Android Keystore, use encrypted storage for sensitive data and enforce HTTPS with a network security config. The Play Integrity API can check that requests come from your genuine app on a real device, which helps against fraud and abuse. Play App Signing keeps your upload key safe and recoverable. We also keep dependencies current, because outdated SDKs are a common source of policy warnings.

Skills and tools our Android developers use

Languages and UI

  • Kotlin
  • Jetpack Compose
  • Material 3
  • Java (legacy)
  • XML views
  • Compose for Wear OS

Architecture and Jetpack

  • ViewModel
  • Kotlin coroutines and Flow
  • Hilt
  • Room
  • DataStore
  • WorkManager
  • Navigation Compose
  • Paging 3

Firebase and services

  • Firebase Cloud Messaging
  • Crashlytics
  • Remote Config
  • Firebase Auth
  • Firestore
  • Google Play Billing
  • Play Integrity API

Testing and quality

  • JUnit
  • Compose UI tests
  • Espresso
  • Robolectric
  • Firebase Test Lab
  • Android Studio Profiler
  • Baseline Profiles

Build and release

  • Android Studio
  • Gradle
  • Android App Bundle
  • Play Console
  • fastlane
  • GitHub Actions
  • Firebase App Distribution

Why Dware

Why hire Android developers from Dware

Engineers who have shipped on Google Play

Our Android developers have taken real apps through Play review, policy updates and yearly target API changes. They know which choices cause trouble before a reviewer flags them.

Tested on the phones your users own

We test on a real device mix, not just the newest Pixel. That catches the crashes and layout bugs your users would otherwise find for you.

Matched in 48 hours, with a risk-free start

Tell us what you need and we match you with an Android developer within 48 hours. Your first two weeks are a risk-free trial.

You own everything

Code lives in your repository and the app lives in your Play Console account, with Play App Signing under your control. You own all code and IP, and we sign an NDA on request.

Clear updates and flexible terms

You get daily or weekly updates and a fresh test build every sprint. Scale the team up or down month to month as your roadmap changes.

Ways to work with us

Ways to hire Android developers

Hire one developer, add a whole team, or hand us a fixed-scope project. Tell us what you need and we'll send a free, fixed quote, usually within one business day.

Dedicated developer

Most popular

A senior engineer who works only on your product, full-time or part-time.

  • Joins your Slack, standups and Git
  • Same developer every day
  • Scale up or down monthly

Team extension

Two or more developers, plus QA or a tech lead, added to your team.

  • Matched to your stack and time zone
  • One point of contact
  • Add or remove people any month

Fixed-scope project

A clear scope, timeline and fixed quote. Ideal for MVPs, apps and fixes.

  • Free, fixed quote before we start
  • Milestones you approve
  • Support after launch

FAQ

Hire Android developers: frequently asked questions

Should I build a native Android app or use a cross-platform framework?

If you need iOS and Android quickly with one team, React Native or Flutter can be the right choice. Native Android with Kotlin is better when the app depends on deep device features, heavy background work, Bluetooth, Wear OS or the best possible performance on low-end phones. Kotlin Multiplatform is also an option to share business logic with iOS while keeping native UI. We build all of these and will recommend what fits your product.

How much does it cost to hire an Android developer?

Cost depends on the number of screens and features, the backend and integrations you need, background work, payments, which devices and form factors you support, your timeline and the size of the team. A simple MVP and a large app with offline sync, billing and a Wear OS companion are very different projects. After a short call we give you a free, fixed quote so you know the full cost before work begins.

How long does it take to build an Android app?

A focused MVP usually takes 8 to 14 weeks. You get the first internal test build in 1 to 2 weeks and a new one each sprint. If your app is published on a new personal developer account, Google requires a closed test with at least 12 testers for 14 days before production, so we plan that in. Organization accounts skip that step, which is one reason we usually suggest one for business apps.

How do you deal with so many Android devices and versions?

We choose a minimum Android version based on your users, use AndroidX libraries that handle version differences and test on a real mix of brands, screen sizes and memory levels. Firebase Test Lab lets us run tests on many more models. We pay special attention to manufacturers known for aggressive battery saving, because they can stop background tasks and notifications that work fine on a Pixel.

What are Google Play testing tracks?

The Play Console has internal, closed and open testing tracks plus production. Internal testing is for up to 100 people on your team and builds are available within minutes. Closed testing is for invited testers, such as beta users, and open testing lets anyone join from the store. We use internal testing every sprint, closed testing before launch and staged rollouts in production, so problems reach as few users as possible.

My app was rejected or removed by Google Play. Can you help?

Yes. We read the policy email and Play Console notes, find the exact policy involved and fix the app, the listing or the declarations. Common causes are an inaccurate Data safety form, an SDK collecting data you did not declare, background location without a valid reason, missing account deletion or payment flows that should use Google Play Billing. Then we resubmit or file an appeal with a clear explanation.

Can you move our old Java app to Kotlin and Jetpack Compose?

Yes, and we do it gradually. Kotlin and Java work in the same project, and Compose screens can sit inside existing XML layouts and the other way round. We start with the parts you change most often, add tests around them and convert step by step. You keep releasing features during the migration, and the risk is far lower than a full rewrite.

Do you build Wear OS and tablet versions too?

Yes. We build adaptive layouts for tablets, foldables and Chromebooks using window size classes, so one app works well on every screen. For watches we build Wear OS apps, tiles and complications with Compose for Wear OS. They can work alone or sync with your phone app through the Wearable Data Layer API. Good large-screen support also helps your app show up for tablet users on Google Play.

Who owns the app and the Google Play account?

You do. The app is published from your own Google Play Console account, and we join it with only the permissions we need. Play App Signing keeps your signing key safe with Google, and the upload key and code live in your repository. You own all code and IP from day one, and we sign an NDA on request.

What happens after the app launches?

We offer post-launch support: crash and ANR monitoring, bug fixes, replies to Play reviews and new features. Every year Google raises the target API level that updates must meet, usually with a deadline in late summer. We test on Android betas early and update your target SDK in time, so you never lose the ability to publish updates.

Tell us about your Android app

Share your idea or your current app and we will come back with a plan, a timeline and a free, fixed quote. Book a free consultation and meet your Android developer within 48 hours.

Email hello@dware.devFree quote · NDA on request