> [!NOTE]
> Android developer verification is a new requirement designed to link individuals and organizations to their Android apps. Starting in 2026, Android will require all apps to be registered by verified developers in order to be installed by users on certified Android devices. To learn what you need to do, see [Android
> developer verification](https://developer.android.com/developer-verification/guides).

To prepare your app for release, you need to configure, build, and test a
release version of your app. The configuration tasks involve basic code
cleanup and code modification tasks that help optimize your app. The build
process is similar to the debug build process and can be done using JDK and
Android SDK tools.

## Android skills

[View on GitHub](https://github.com/android/skills/blob/main/play/play-policy-insights)

### Check Google Play Policy

Use the `play-policy-insights` [Android skill](https://developer.android.com/tools/agents/android-skills) to audit your app for Google Play Policy compliance. To install the skill from the [Android CLI](https://developer.android.com/tools/agents/android-cli), run:

    android skills add play-policy-insights

Testing tasks serve as a final check, helping ensure that your app performs
as expected under real-world conditions. Firebase offers a large set of both
physical and virtual test devices through [Firebase Test Lab](https://firebase.google.com/products/test-lab) that
you can use to improve your app quality.

When you are finished preparing your app for release, you have a signed APK
file, which you can distribute directly to users or distribute through an app
marketplace such as [Google Play](https://play.google.com).

This document summarizes the main tasks you need to perform to prepare your
app for release. The tasks described on this page apply to all Android apps,
regardless of how they are released or distributed to users. If you are
releasing your app through Google Play, read [Release with
confidence](https://developer.android.com/distribute/best-practices/launch/launch-checklist).

**Note:** As a best practice, make sure your app
meets all of your release criteria for functionality, performance, and
stability before you perform the tasks outlined on this page.
![Shows how the preparation process fits into the development process](https://developer.android.com/static/images/publishing/publishing_overview_prep.png)


**Figure 1.** Preparing for release is a required development
task and is the first step in the publishing process.

## Tasks to prepare for release

To release your app to users, you need to create a release-ready package that
users can install and run on their Android-powered devices. The release-ready
package contains the same components as the debug APK file---compiled source
code, resources, manifest file, and so on---and is built using the same build
tools. However, unlike the debug APK file, the release-ready APK file is signed
with your own certificate and is optimized with the `zipalign`
tool.
![Shows the five tasks you perform to prepare your app for release](https://developer.android.com/static/images/publishing/publishing_preparing.png)


**Figure 2.** There are five main tasks to prepare your app for
release.

The signing and optimization tasks are usually seamless if you are building
your app with Android Studio. For example, you can use Android Studio with the
Gradle build files to compile, sign, and optimize your app all at once. You can
also configure the Gradle build files to do the same when you build from the
command line. For more details about using the Gradle build files, see [Configure your build](https://developer.android.com/studio/build).

To prepare your app for release, you typically perform five main tasks, as
shown in figure 2. Each main task may include one or more smaller tasks,
depending on how you are releasing your app. For example, if you are releasing
your app through Google Play, you may want to add special filtering rules to
your manifest while you are configuring your app for release. Similarly, to
meet Google Play publishing guidelines you may have to prepare screenshots and
create promotional text while you are gathering materials for release.

You usually perform the tasks listed in figure 2 after you have thoroughly
debugged and tested your app. The Android SDK contains several tools to help
you test and debug your Android apps. For more information, see [Debug your app](https://developer.android.com/tools/debugging) and [Test your app](https://developer.android.com/tools/testing).

## Gather materials and resources

To prepare your app for release, you need to gather several supporting items.
At a minimum, this includes cryptographic keys for signing your app and an app
icon. You might also want to include an end-user license agreement.

### Cryptographic keys

Android requires that all APKs are digitally signed with a certificate
before they are installed on a device or updated. For [Google Play Store](https://play.google.com), all apps created after
August 2021 are required to use [Play App
Signing](https://developer.android.com/studio/publish/app-signing#app-signing-google-play). But uploading your AAB to Play Console still requires you to sign
it with your developer certificate. Older apps can still self-sign, but whether
you're using Play App Signing or you're self-signing, you must sign your app
before you can upload it.

To learn about certificate requirements, see [Sign your app](https://developer.android.com/tools/publishing/app-signing).

**Important:** Your app must be signed with a
cryptographic key that has a validity period ending after October 22,
2033.

You might also have to obtain other release keys if your app accesses a
service or uses a third-party library that requires you to use a key that is
based on your private key.

### App icon

Your app's icon helps users identify your app on a device's Home screen and
in the Launcher window. It also appears in Manage Applications, My Downloads,
and elsewhere. In addition, publishing services such as Google Play display
your icon to users. Be sure you have an app icon and that it meets the
recommended [icon guidelines](https://material.io/design/iconography/product-icons.html#design-principles).

**Note:** If you are releasing your app on Google
Play, you need to create a high-resolution version of your icon. See
[Add
preview assets to showcase your app](https://www.google.com/support/androidmarket/developer/bin/answer.py?answer=1078870) for more information.

### End-user license agreement

Consider preparing an end-user license agreement (EULA) for your app. A EULA
can help protect your person, organization, and intellectual property, and we
recommend that you provide one with your app.

### Miscellaneous materials

You might also have to prepare promotional and marketing materials to
publicize your app. For example, if you are releasing your app on Google Play,
you will need to prepare some promotional text and you will need to create
screenshots of your app. For more information, see
[Add
preview assets to showcase your app](https://www.google.com/support/androidmarket/developer/bin/answer.py?answer=1078870).

## Configure your app for release

After you gather all of your supporting materials, you can start configuring
your app for release. This section provides a summary of the configuration
changes we recommend that you make to your source code, resource files, and app
manifest prior to releasing your app.

Although most of the configuration changes listed in this section are
optional, they are considered good coding practices and we encourage you to
implement them. In some cases, you might already have made these configuration
changes as part of your development process.

### Choose a suitable application ID

Make sure you choose an application ID that is suitable over the life of your
app. You can't change the application ID after you distribute your app to
users. To set it, use the `applicationId` property in the
module-level `build.gradle` or `build.gradle.kts` file. For
more information, see [Set the application
ID](https://developer.android.com/studio/build/configure-app-module#set-application-id).

### Turn off debugging

To configure whether the APK is debuggable, use the `debuggable`
flag for Groovy or the `isDebuggable` flag for Kotlin script:

### Kotlin

```kotlin
  android {
    ...
    buildTypes {
      release {
        isDebuggable = false
        ...
      }
      debug {
        isDebuggable = true
        ...
      }
    }
    ...
  }
  
```

### Groovy

```groovy
  android {
    ...
    buildTypes {
      release {
        debuggable false
        ...
      }
      debug {
        debuggable true
        ...
      }
    }
    ...
  }
```

### Enable and configure app shrinking

Many of the following optimizations can be automated by enabling [shrinking](https://developer.android.com/studio/build/shrink-code) for your release build. For
example, you can add ProGuard rules to remove log statements, and the shrinker
will identify and remove unused code and resources. The shrinker can also
replace class and variable names with shorter names to further reduce DEX
size.

### Turn off logging

Deactivate logging before you build your app for release. You can deactivate
logging by removing calls to `https://developer.android.com/reference/android/util/Log` methods in your source
files. Also, remove any log files or static test files that were created in
your project.

Also, remove all `https://developer.android.com/reference/android/os/Debug`
tracing calls that you added to your code, such as
[`startMethodTracing()`](https://developer.android.com/reference/android/os/Debug#startMethodTracing())
and
[`stopMethodTracing()`](https://developer.android.com/reference/android/os/Debug#stopMethodTracing())
method calls.

**Important:** Ensure that you disable
debugging for your app if using [`WebView`](https://developer.android.com/reference/android/webkit/WebView) to display
paid content or if using JavaScript interfaces, because debugging lets users
inject scripts and extract content using Chrome DevTools. To disable
debugging, use the
[`WebView.setWebContentsDebuggingEnabled()`](https://developer.android.com/reference/android/webkit/WebView#setWebContentsDebuggingEnabled(boolean))
method.

### Clean up your project directories

Clean up your project and make sure it conforms to the directory structure
described in [Projects overview](https://developer.android.com/tools/projects#ApplicationProjects).
Leaving stray or orphaned files in your project can prevent your app from
compiling and cause your app to behave unpredictably. At a minimum, perform the
following cleanup tasks:

- Review the contents of your `cpp/`, `lib/`, and `src/` directories. The `cpp/` directory should contain only source files associated with the [Android NDK](https://developer.android.com/tools/sdk/ndk), such as C or C++ source files, header files, or makefiles. The `lib/` directory should contain only third-party library files or private library files, including prebuilt shared and static libraries. The `src/` directory should contain only the source files for your app (Java, Kotlin, and AIDL files). The `src/` directory shouldn't contain any JAR files.
- Check your project for private or proprietary data files that your app doesn't use and remove them. For example, look in your project's `res/` directory for old drawable files, layout files, and values files that you are no longer using and delete them.
- Check your `lib/` directory for test libraries and remove them if they are no longer being used by your app.
- Review the contents of your `assets/` directory and your `res/raw/` directory for raw asset files and static files that you need to update or remove prior to release.

### Review and update your manifest and Gradle build settings

Verify that the following manifest and build files items are set
correctly:

- `https://developer.android.com/guide/topics/manifest/uses-permission-element` element

  Specify only those permissions that are relevant and required for your
  app.
- `android:icon` and `android:label` attributes

  You must specify values for these attributes, which are located in the
  `https://developer.android.com/guide/topics/manifest/application-element` element.
- `versionCode` and `versionName` properties

  We recommend that you specify values for these properties, which are
  located in the app module-level `build.gradle` or
  `build.gradle.kts` file. For more information, see [Version your app](https://developer.android.com/tools/publishing/versioning).

There are several additional build file elements that you can set if you
are releasing your app on Google Play. For example, the `minSdk` and
`targetSdk` attributes, which are located in the app module-level
`build.gradle` or `build.gradle.kts` file. For more
information about these and other Google Play settings, see [Filters on Google Play](https://developer.android.com/google/play/filters).

### Address compatibility issues

Android provides several tools and techniques to make your app compatible
with a wide range of devices. To make your app available to the largest number
of users, consider doing the following:

Add support for multiple screen configurations.
:   Make sure you meet the best practices for
    [supporting multiple screens](https://developer.android.com/guide/practices/screens_support#screen-independence). By supporting multiple screen configurations,
    you can create an app that functions properly and looks good on any of the screen sizes
    supported by Android.

Optimize your app for larger displays.
:   You can optimize your app to work well on devices with large displays
    such as tablets and foldables. For example, [list-detail layouts](https://developer.android.com/guide/topics/large-screens/large-screen-canonical-layouts#list-detail) can improve usability on larger screens.

Consider using Jetpack libraries.
:   Jetpack is a suite of libraries to help developers follow best
    practices, reduce boilerplate code, and write code that works consistently
    across Android versions and devices.

### Update URLs for servers and services

If your app accesses remote servers or services, make sure you are using
the production URL or path for the server or service and not a test URL or
path.

### Implement licensing for Google Play

If you are releasing a paid app through Google Play, consider adding support
for Google Play Licensing. Licensing lets you control access to your app based
on whether the current user has purchased it. Using Google Play Licensing is
optional, even if you are releasing your app through Google Play.

For more information about the Google Play Licensing Service and how to use
it in your app, see [App
Licensing](https://developer.android.com/google/play/licensing).

## Build your app for release

After you finish configuring your app, you can build it into a release-ready
APK file that is signed and optimized. The JDK includes the tools for signing
the APK file (Keytool and Jarsigner); the Android SDK includes the tools for
compiling and optimizing the APK file. If you are using Android Studio or you
are using the Gradle build system from the command line, you can automate the
entire build process. For more information about configuring Gradle builds, see
[Configure build
variants](https://developer.android.com/tools/building/configuring-gradle).

If you are using a [continuous integration
system](https://developer.android.com/studio/projects/continuous-integration), you can configure a task to automate your release process. This is
not limited to building your release APK or AAB. You can also configure it to
automatically upload the build artifact(s) to Play Console.

### Build with Android Studio

You can use the Gradle build system, integrated with Android Studio, to build
a release-ready APK file that is signed with your private key and optimized. To
learn how to set up and run builds from Android Studio, see [Build and run your app](https://developer.android.com/tools/building/building-studio).

The build process assumes that you have a certificate and private key
suitable for signing your app. If you don't have a suitable certificate and
private key, Android Studio can help you generate one. For more information
about the signing process, see [Sign your app](https://developer.android.com/tools/publishing/app-signing).

## Prepare external servers and resources

If your app relies on a remote server, make sure the server is secure and that
it is configured for production use. This is particularly important if you are
implementing [in-app billing](https://developer.android.com/google/play/billing) in
your app and you are performing the signature verification step on a remote
server.

Also, if your app fetches content from a remote server or a real-time service
(such as a content feed), be sure the content you are providing is up to date
and production ready.

## Test your app for release

Testing the release version of your app helps ensure that your app runs
properly under realistic device and network conditions. Ideally, test your app
on at least one handset-sized device and one tablet-sized device to verify that
your user interface elements are sized correctly and that your app's performance
and battery efficiency are acceptable. [Firebase Test Lab](https://firebase.google.com/docs/test-lab) can also
be useful for testing across a variety of different devices and Android OS
versions.

As a starting point for testing, see [Core app quality](https://developer.android.com/tools/testing/what_to_test). When you are done
testing and satisfied that the release version of your app behaves correctly,
you can release your app to users. For more information, see [Release
your app to users](https://developer.android.com/tools/publishing/publishing_overview#publishing-release).