Home›developwith — developer tips›How-To Guides›Mobile›How to publish an app to the Google Play Store

How to publish an app to the Google Play Store

A complete end-to-end guide covering Google Play Developer accounts, signing keys, AAB/APK builds, Play Console metadata, and submission.

Publishing an Android app to the Google Play Store involves creating a developer account, generating a signing key, building a signed Android App Bundle (AAB), configuring Play Console metadata, and submitting for review. This guide covers every step from scratch.

Table of contents

  1. Prerequisites
  2. Create a Google Play Developer account
  3. Create a signing key (keystore)
  4. Enroll in Google Play App Signing (recommended)
  5. Configure your project for release
  6. Build a signed Android App Bundle
  7. Create the app in Play Console
  8. Fill in Store listing metadata
  9. Upload the AAB and create a release
  10. Set up content rating
  11. Submit for review
  12. Post-release: updates & maintenance
  13. CI/CD automation
  14. Troubleshooting

Prerequisites

1. Create a Google Play Developer account

  1. Go to Google Play Console.
  2. Sign in with your Google account.
  3. Follow the prompts:
    • Select Account type — Personal or Organization.
    • For Organization accounts, you’ll need to verify your D-U-N-S number and legal entity details.
  4. Pay the $25 USD one-time registration fee.
  5. Complete identity verification (Google may require a government-issued ID and a video call for personal accounts, or business documentation for organization accounts).
  6. Wait for approval (typically 1–3 business days, sometimes up to 7).

Important: Google has been increasing identity verification requirements. Ensure your account name matches your legal name or registered business name exactly.

2. Create a signing key (keystore)

Every Android app must be digitally signed with a keystore before it can be installed or published. This key identifies you as the developer and is required for all updates.

Generate a keystore with Android Studio

  1. In Android Studio: Build → Generate Signed Bundle / APK…
  2. Select Android App Bundle → Next.
  3. Click Create new… under Key store path.
  4. Fill in:
    • Key store path — choose a secure location (e.g. ~/keystores/myawesomeapp.jks)
    • Password — a strong password for the keystore
    • Key alias — e.g. myawesomeapp
    • Key password — can be the same as the keystore password
    • Certificate — fill in at least your name in the first field; the rest are optional
  5. Click OK. The keystore file is created.

Generate a keystore from the command line

keytool -genkeypair -v \
  -keystore myawesomeapp.jks \
  -keyalg RSA \
  -keysize 2048 \
  -validity 10000 \
  -alias myawesomeapp \
  -storepass YOUR_KEYSTORE_PASSWORD \
  -keypass YOUR_KEY_PASSWORD

Parameters:

⚠️ Back up your keystore

This is critical. If you lose your keystore or passwords:

Store your keystore file and passwords in multiple secure locations:

Google Play App Signing lets Google manage your app’s signing key. Benefits:

Enroll during app creation

  1. In Play Console, when creating a new app, you’ll be prompted to opt in to Play App Signing.
  2. You can either:
    • Use Google-generated key — Google creates and manages the signing key for you. Easiest option.
    • Use an existing key — export your existing keystore and upload it.

Opt in for an existing app

  1. Go to Play Console → your app → Setup → App signing.
  2. Follow the instructions to opt in.
  3. Download the upload key certificate and use it for signing uploads.

Note: If you use Google-generated signing, your upload key is separate from the production key. If you lose your upload key, you can request a new one from Google. If you opted out and lost your production key, you’re stuck.

4. Configure your project for release

Build configuration in build.gradle

android {
    defaultConfig {
        applicationId "com.yourdomain.myawesomeapp"
        minSdk 24
        targetSdk 35   // Use the latest stable SDK
        versionCode 1  // Must be an integer, increment for each release
        versionName "1.0.0"
    }

    buildTypes {
        release {
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'),
                          'proguard-rules.pro'
        }
    }
}

Key fields:

App icons

Create adaptive icons (mipmap-anydpi-v26/ic_launcher.xml + ic_launcher_round.xml) and provide legacy icons in mipmap-mdpi through mipmap-xxxhdpi.

The 512×512 Play Store icon must be:

Version policy

Field Format Rule
versionCode Integer (e.g. 1, 2, 3) Must be higher than any previous upload
versionName String (e.g. "1.0.0") Shown to users in the store

A common scheme: versionCode = MAJOR * 10000 + MINOR * 100 + PATCH (e.g. 1.2.3 = 10203).

5. Build a signed Android App Bundle

Google Play requires Android App Bundle (.aab) format — not APK — for new submissions.

Build with Android Studio

  1. Build → Generate Signed Bundle / APK…
  2. Select Android App Bundle → Next.
  3. Select your keystore file and enter passwords.
  4. Select the release build variant.
  5. Check Export encrypted key if you want a pepline mapping (optional).
  6. Click Finish. The .aab file is generated in app/release/.

Build from the command line

# Debug build (for testing only)
./gradlew bundleDebug

# Release build (for Play Store)
./gradlew bundleRelease

The output AAB is at app/build/outputs/bundle/release/app-release.aab.

Verify the bundle

# Check bundle contents
bundletool dump bundle --bundle=app-release.aab

# Verify signing
jarsigner -verify -verbose -certs app-release.aab

6. Create the app in Play Console

  1. Go to Google Play Console.
  2. Click Create app.
  3. Fill in:
    • App name — displayed on the store
    • Default language — the primary language for your listing
    • App or game — select the appropriate category
    • Free or paid — you cannot change from paid to free later
  4. Check the Developer Program Policies and Play Store Signing declarations.
  5. Click Create app.

Dashboard checklist

After creating the app, Play Console shows a dashboard with tasks you must complete before publishing:

7. Fill in Store listing metadata

Navigate to your app → Grow → Store presence → Main store listing.

Required fields

Field Details Limits
App name Your app’s name on the store Max 30 characters
Short description Shown at the top of the listing Max 80 characters
Full description Detailed description Max 4000 characters
App icon 512×512 PNG, no alpha —
Feature graphic 1024×500 PNG or JPEG, no alpha Required for featuring
Screenshots Min 2, max 8 per device type PNG or JPEG
Category App or Game + subcategory —
Contact details Email (required), phone, website —
Privacy policy URL to your privacy policy Required

Screenshots

You must provide at least 2 screenshots per device type. Recommended sizes:

Device type Recommended dimensions
Phone 1080 × 1920 or 1440 × 2560
7-inch tablet 1200 × 1920
10-inch tablet 1600 × 2560

Tip: Use Android Studio’s Virtual Device screenshots or fastlane screengrab for automated screenshots across device sizes.

Feature graphic

The 1024×500 feature graphic is required if you want your app to be eligible for featuring in the Play Store. It’s displayed at the top of your listing and in promotions.

8. Upload the AAB and create a release

Create a release

  1. In Play Console, go to your app → Release → Production (or start with Internal testing or Closed testing for staged rollouts).
  2. Click Create new release.
  3. Under App bundles, either:
    • Drag and drop your .aab file, or
    • Use the Google Play Developer API / fastlane for CI/CD uploads.
  4. Under Release details, enter a release name (e.g. “1.0.0”) and release notes (what’s new in this version).

Review and roll out

  1. Review any warnings or errors (Play Console validates the bundle).
  2. Click Next → Review release.
  3. Click Start rollout to Production (or your chosen track).

Recommended workflow: Start with Internal testing → Closed testing → Open testing → Production. This lets you catch issues before a wide release.

9. Set up content rating

Google requires an IARC content rating for every app.

  1. Go to your app → Setup → Content rating.
  2. Click Start questionnaire.
  3. Answer questions about your app’s content (violence, sexual content, language, etc.).
  4. Submit the questionnaire.
  5. Google assigns a rating (e.g., E for Everyone, T for Teen, M for Mature).

Warning: Incorrect ratings can result in app removal. Be honest and thorough in the questionnaire.

10. Submit for review

  1. Ensure all dashboard checklist items are completed (green checkmarks).
  2. Review your app’s Data safety section (declare what data you collect and why).
  3. Review Target audience and content (age appropriateness).
  4. Click Start rollout to Production or your chosen track.
  5. The app enters Review status — typically 1–3 business days for new apps, hours for updates.

Review timeline

Common rejection reasons

11. Post-release: updates & maintenance

Releasing an update

  1. Increment versionCode and versionName in build.gradle.
  2. Build a new signed AAB.
  3. In Play Console → Release → Production → Create new release.
  4. Upload the new AAB, add release notes, and roll out.

Staged rollouts

You can roll out updates gradually:

To do this: after creating a release, click Manage rollout and select the percentage.

Managing your signing key

Responding to reviews

Use the Play Console → Reviews section to respond to user reviews. This improves ratings and shows users you’re engaged.

CI/CD automation

fastlane

fastlane is the standard automation tool for Android deployments:

# Install fastlane
gem install fastlane

# Initialize in your project
fastlane init

Example Fastfile

default_platform(:android)

platform :android do
  desc "Build and upload to Google Play"
  lane :release do
    # Build the AAB
    gradle(task: "bundleRelease")

    # Upload to Play Console
    upload_to_play_store(
      track: "production",
      aab: "app/build/outputs/bundle/release/app-release.aab",
      json_key: "path/to/service-account-key.json"
    )
  end

  desc "Promote from beta to production"
  lane :promote do
    promote_to_production(track: "beta")
  end
end

Service account for API access

To use the Google Play Developer API (required for fastlane and CI/CD):

  1. Go to Google Cloud Console.
  2. Create a project (or use an existing one linked to your Play Console).
  3. Go to IAM & Admin → Service Accounts → Create Service Account.
  4. Grant the role “Service Account User”.
  5. Create a JSON key and download it — this is your service-account-key.json.
  6. In Play Console → Setup → API access, link your Cloud project and grant the service account permissions.

⚠️ Security: Never commit your service account key to version control. Store it in a secure environment variable or secrets manager.

GitHub Actions example

name: Deploy to Play Store

on:
  push:
    tags:
      - 'v*'

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          distribution: temurin
          java-version: 17
      - name: Build AAB
        run: ./gradlew bundleRelease
      - name: Deploy to Play Store
        uses: maierj/[email protected]
        with:
          lane: android release
        env:
          SERVICE_ACCOUNT_KEY: ${{ secrets.SERVICE_ACCOUNT_KEY }}
          KEYSTORE_BASE64: ${{ secrets.KEYSTORE_BASE64 }}
          KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}

Troubleshooting

“Upload failed: You need to use a different version code”

Increment versionCode in build.gradle. Every upload must have a unique, higher version code.

“Your app is not signed”

Ensure you’re building with the correct keystore. Check your signingConfigs in build.gradle:

android {
    signingConfigs {
        release {
            storeFile file("/path/to/myawesomeapp.jks")
            storePassword "YOUR_KEYSTORE_PASSWORD"
            keyAlias "myawesomeapp"
            keyPassword "YOUR_KEY_PASSWORD"
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
        }
    }
}

Best practice: Don’t hardcode passwords in build.gradle. Load them from environment variables or local.properties (which should be in .gitignore).

“APK has been rejected due to policy violation”

Read the rejection email carefully. Common issues include:

“Bundle is not signed correctly”

Verify the signing certificate:

keytool -printcert -jarfile app-release.aab

Compare the SHA-1 fingerprint with the one registered in Play Console → Setup → App signing.

“Package name already exists”

Package names are globally unique on Google Play. If someone else has already published an app with your desired package name, you must choose a different one.

Checklist