Introduction

Building an Android application is only one part of Android development. After developing and testing an app, the next important step is publishing it on the Google Play Store.

Google Play allows developers to distribute their applications to Android users around the world. However, publishing an app requires more than uploading an APK file. Developers must prepare a signed Android App Bundle, create a Play Console account, complete the store listing, provide policy declarations, test the application, and submit it for review.

In this tutorial, we will learn the complete process of publishing an Android application on Google Play using Android Studio.

By the end of this tutorial, you will understand how to prepare, test, and submit an Android application for production release.

1. What Is Google Play Console?

Google Play Console is Google's official platform for publishing and managing Android applications on the Google Play Store.

Developers use Play Console to:

• Create and manage Android applications.

• Upload Android App Bundles.

• Manage internal, closed, and open testing.

• Create store listings.

• Complete app content and policy declarations.

• Publish new app versions.

• Monitor downloads, crashes, ratings, and performance.

You can access Google Play Console here:

https://play.google.com/console/

2. Create a Google Play Console Developer Account

Before publishing an application, you need a Google Play Console developer account.

Follow these steps:

1. Open the Google Play Console website.

2. Sign in using your Google Account.

3. Select the option to create a developer account.

4. Choose the appropriate account type: Personal or Organization.

5. Accept the Developer Distribution Agreement.

6. Pay the one-time registration fee of US$25.

7. Provide the required identity and contact information.

8. Complete the verification steps requested by Google.

You must be at least 18 years old to register a Play Console developer account.

Google may request government identification and additional information to verify your identity. The exact requirements depend on the account type.

Important: Personal developer accounts created after November 13, 2023 must complete Google's required closed-testing process before applying for production access.

3. Prepare Your Android Application

Before uploading your application, make sure it is ready for release.

Open your project in Android Studio and check the following items:

• The application runs without crashing.

• All buttons and features work correctly.

• Login and registration functionality work properly, if available.

• Database operations are working correctly.

• Internet connectivity and API requests work correctly, if required.

• The app has been tested on an emulator and a real Android device.

• Unnecessary permissions have been removed.

• Debugging code and test credentials have been reviewed.

Also check your application's identity.

Application ID

The application ID uniquely identifies your Android application on Google Play.

For example:

android {
    namespace 'com.paramclasses.studentapp'

    defaultConfig {
        applicationId 'com.paramclasses.studentapp'
        minSdk 23
        targetSdk 36
        versionCode 1
        versionName "1.0"
    }
}

The example uses Android 16 (API level 36) as the target SDK because, as of November 4, 2026, Google Play requires new mobile apps and app updates to target API level 36 or higher.

The minimum SDK is an example only. Select it according to your application's compatibility requirements.

Important: Once an application is published, changing its application ID creates a different app listing. Keep the original application ID for future updates.

4. Understand Version Code and Version Name

Android applications use two important version values.

versionCode

• An integer used internally by Android and Google Play.

• Every update must use a higher version code than the previous release.

• It cannot be reused for a newer release.

versionName

• A user-friendly version label.

• It appears in application information.

• Examples include 1.0, 1.1, and 2.0.

Example:

defaultConfig {
    applicationId 'com.paramclasses.studentapp'
    versionCode 2
    versionName "1.1"
}

When you publish your next update, increase the version code.

5. Generate a Signed Android App Bundle (AAB)

Google Play uses Android App Bundles for publishing new applications.

An AAB file contains the compiled application and resources needed by Google Play to generate optimized APKs for users' devices.

Follow these steps in Android Studio:

1. Open your Android project.

2. Select the Build menu.

3. Select Generate Signed Bundle / APK.

4. Choose Android App Bundle.

5. Click Next.

6. Select your application module.

7. Create a new Key Store or select an existing one.

8. Enter the required keystore and key passwords.

9. Enter the key alias and certificate details.

10. Select the release build variant.

11. Click Create or Finish.

Android Studio will generate your signed AAB file.

The output is generally available inside:

app/release/

The exact output directory can vary depending on your Android Studio and Gradle configuration.

What Is a Keystore?

A keystore is a file that stores cryptographic keys and certificates used to sign your application.

Keep your keystore and passwords secure. Never upload them to a public repository or share them with unauthorized people.

What Is Play App Signing?

Play App Signing is Google's application-signing system.

For a new application, you normally sign the uploaded AAB using an upload key. Google manages the app signing key and uses it to sign the APKs delivered to users.

Remember:

• Upload key: Used to authenticate your uploaded app bundle.

• App signing key: Used by Google Play to sign the APKs delivered to users.

Keep a secure backup of your upload keystore and credentials.

6. Create a New Application in Google Play Console

After generating your AAB file, open Google Play Console.

Follow these steps:

1. Sign in to your developer account.

2. Open the Play Console dashboard.

3. Click Create app.

4. Enter your application name.

5. Select the default language.

6. Choose whether your app is an app or a game.

7. Select whether the application is free or paid.

8. Confirm the required declarations.

9. Click Create app.

Your application will now appear in the Play Console dashboard.

The exact setup screens can change as Google updates Play Console.

7. Create Your Google Play Store Listing

The store listing is the information users see when they visit your application's Play Store page.

Open:

Grow users → Store presence → Main store listing

Add the following information:

App Name

Enter a clear and meaningful application name.

Example:

Student Management System

Short Description

Write a short explanation of what your application does.

Example:

Manage student records, attendance, and academic information in one place.

Full Description

Explain the application's features, functionality, and benefits.

Example:

The Student Management System helps users manage student information efficiently. Users can add student records, update details, view information, and manage academic data through a simple interface.

App Icon

Upload a high-resolution app icon.

Google Play's required app listing icon specifications include:

• Dimensions: 512 × 512 pixels.

• Format: 32-bit PNG with alpha.

• Maximum file size: 1 MB.

Screenshots

Upload screenshots that show the real application interface.

Screenshots should clearly demonstrate the application's important features.

Google Play requires at least two screenshots across supported device types for a standard app listing. Follow the current device-specific asset requirements shown in Play Console.

Feature Graphic

Prepare a feature graphic with these specifications:

• Dimensions: 1024 × 500 pixels.

• Format: JPEG or 24-bit PNG without alpha.

Use original graphics and genuine application screenshots. Do not use misleading images or claim features that your app does not provide.

8. Complete App Content and Policy Declarations

Before submitting your app, Google requires developers to provide information about the application's content, safety, and data practices.

Open:

Policy and programs → App content

Complete the declarations that apply to your application.

Privacy Policy

Provide a privacy policy URL that explains how your application collects, uses, stores, and shares user data.

Follow Google's current privacy-policy requirements. Where required, the policy must also be accessible inside your application.

Data Safety

Complete the Data Safety form accurately.

Declare:

• What user data your application collects.

• Whether data is shared with third parties.

• How data is protected.

• Whether users can request data deletion, where applicable.

Your declarations must reflect the application itself and all included SDKs.

Ads Declaration

Declare whether your application contains advertisements.

If your app displays ads through an advertising SDK, select the appropriate answer.

Content Rating

Complete the content rating questionnaire.

Google Play uses your answers to determine the appropriate content rating for your application.

Target Audience

Select the age groups your application is designed for.

If your application targets children, additional Google Play Families requirements may apply.

App Access

If your application has restricted areas, such as a login screen, provide the reviewer with the necessary access instructions and test credentials.

Do not submit an app that reviewers cannot properly access or evaluate.

You may also need to complete other declarations depending on your app's functionality, permissions, and category.

9. Understand Google Play Testing Tracks

Before publishing an application to everyone, you should test it using Play Console testing tracks.

Google Play provides three main testing tracks.

Internal Testing

Internal testing allows you to distribute your application to a small group of testers.

It is useful for checking:

• Application installation.

• Login and registration.

• Navigation.

• Database functionality.

• Important features.

• Basic stability.

Closed Testing

Closed testing allows you to distribute your application to a selected group of testers.

You can collect feedback, identify bugs, and improve the application before production.

Important requirement: For personal developer accounts created after November 13, 2023, Google requires a closed test with at least 12 testers continuously opted in for at least 14 days before applying for production access.

After completing the test, you must apply for production access and answer Google's questions.

Open Testing

Open testing allows a broader group of users to join your test, subject to the testing configuration.

It is useful for gathering feedback from more users before a full launch.

10. Upload Your AAB File to a Testing Track

Now upload your signed Android App Bundle.

Follow these steps:

1. Open your application in Play Console.

2. Navigate to Test and release → Testing.

3. Select the testing track you want to use.

4. Click Create new release.

5. Upload your signed .aab file.

6. Enter release notes.

7. Review the release details.

8. Save the release.

9. Follow the required review and rollout steps for that track.

Example release notes:

Version 1.0

- Initial application release.
- Added student registration.
- Added student record management.
- Improved application interface.
- Fixed initial bugs.

After uploading, Google Play processes the app bundle and displays any detected issues.

Resolve blocking errors before proceeding.

11. Prepare Your Production Release

After testing and completing all required declarations, you can prepare your production release.

Open:

Test and release → Production

Follow these steps:

1. Open the Production track.

2. Click Create new release.

3. Upload your approved AAB file if it is not already available for the release.

4. Add release notes.

5. Review the app bundle and release information.

6. Check for errors and warnings.

7. Complete all required dashboard tasks.

8. Submit the release for review or rollout, depending on the available Play Console workflow.

For eligible personal accounts, production access must first be granted after the required closed testing process.

12. Submit Your Application for Google Play Review

Before your application becomes publicly available, Google reviews it against applicable requirements and policies.

During review, Google may check:

• Application functionality.

• Developer policy compliance.

• Data safety declarations.

• Permissions and sensitive data usage.

• Store listing information.

• Content rating and target audience.

• App access and login instructions.

• Technical compatibility.

If Google identifies a problem, it may reject the submission or request changes.

Read the policy issue carefully, correct the problem, and submit an updated release when appropriate.

Review duration can vary. Do not assume that every application will be approved within a fixed number of days.

13. Publish Your Application

After approval, your application can become available on Google Play according to your release and rollout settings.

Once published, users in your selected countries or regions can discover and install the application, subject to device and availability requirements.

You can use Play Console to:

• Monitor installations.

• Review user ratings.

• Read user feedback.

• Monitor crashes and Android Vitals.

• Publish application updates.

• Manage testing and production releases.

For future updates, increase the version code, generate a new signed AAB, and submit it through Play Console.

14. Important Google Play Publishing Requirements in 2026

Google Play requirements change over time. Always check the current requirements before submitting an application.

As of November 4, 2026, important requirements include:

Target API Level

New mobile applications and app updates must target Android 16 (API level 36) or higher from August 31, 2026.

Personal Account Testing

Personal developer accounts created after November 13, 2023 must complete the 12-testers, 14-consecutive-days closed-testing requirement and apply for production access.

Developer Verification

Google has introduced Android developer verification requirements. Developers should check their Play Console dashboard for any pending app-registration or identity-verification tasks.

App Bundle

New Google Play applications should be prepared for publishing using the Android App Bundle format.

Always verify the latest requirements in official Google Play documentation before release.

15. Common Problems While Publishing Android Apps

Problem 1: App Bundle Upload Error

Possible reasons:

• Incorrect signing configuration.

• Invalid AAB file.

• Incorrect version code.

• Application ID conflicts.

Solution: Check your release configuration, signing credentials, and version code.

Problem 2: Target API Level Error

Your application may not meet the current Google Play target API requirement.

Solution: Update the target SDK and test the application against the required Android version.

Problem 3: Privacy Policy Error

Your privacy policy may be missing, inaccessible, or incomplete.

Solution: Provide a valid, publicly accessible privacy policy URL and make sure it accurately describes your application.

Problem 4: Data Safety Declaration Error

Your Data Safety form may not match the actual data collection and sharing practices of your app.

Solution: Review your application code and all integrated SDKs before completing the declaration.

Problem 5: Production Access Not Available

Your personal developer account may not have completed the required testing process.

Solution: Complete the required closed test and apply for production access.

Problem 6: App Rejected During Review

Your application may violate a Google Play policy or contain functionality that does not match its declarations.

Solution: Read the rejection details, fix the identified issue, and submit a compliant update.

16. Practical Example: Publish a Student Management App

Let's understand the publishing workflow using a Student Management App developed in Android Studio with Java.

Assume our application contains:

• Student Registration.

• Student Login.

• Add Student.

• Update Student.

• Delete Student.

• View Student Records.

Follow this practical workflow:

Step 1: Open the Student Management project in Android Studio.

Step 2: Test all application features on an emulator and a real Android device.

Step 3: Set the correct application ID and version information.

Step 4: Generate a signed Android App Bundle.

Step 5: Create a developer account in Google Play Console and complete verification.

Step 6: Create a new application in Play Console.

Step 7: Add the application name, description, icon, and screenshots.

Step 8: Complete the privacy, Data Safety, content rating, ads, and other required declarations.

Step 9: Upload the AAB file to an appropriate testing track.

Step 10: Complete any applicable testing requirements and fix reported issues.

Step 11: Prepare the production release and submit it for review.

Step 12: After approval and rollout, verify the public Play Store listing.

This is the complete publishing workflow for our example application.

17. Final Google Play Publishing Checklist

Before submitting your application, review this checklist:

• Google Play Console developer account created.

• Developer identity and contact details verified.

• Required developer verification tasks completed.

• Application tested on an emulator.

• Application tested on a real Android device.

• Application ID checked.

• Version code and version name configured.

• Target API requirement verified.

• Signed Android App Bundle generated.

• Upload keystore backed up securely.

• App icon prepared.

• Screenshots prepared.

• Feature graphic prepared.

• Short and full descriptions completed.

• Privacy policy provided where required.

• Data Safety form completed accurately.

• Ads declaration completed.

• Content rating questionnaire completed.

• Target audience selected.

• App access instructions provided, if required.

• Required testing completed.

• Production release submitted for review.

Conclusion

Publishing an Android application on Google Play is an important step in the Android development lifecycle.

In this tutorial, we learned how to create a Google Play Console developer account, prepare an Android application, generate a signed AAB file, create a store listing, complete policy declarations, use testing tracks, and submit a production release.

Remember that successful publishing requires both technical preparation and compliance with Google Play policies.

Always test your application carefully, protect your signing credentials, and keep your application updated with the latest Android requirements.

Frequently Asked Questions

1. What is Google Play Console?

Google Play Console is the official platform used by Android developers to publish, manage, test, and monitor applications on Google Play.

2. What is the Google Play Console registration fee?

The standard developer account registration fee is a one-time US$25 payment. Other verification requirements may apply.

3. What is an AAB file?

An Android App Bundle is a publishing format that allows Google Play to generate optimized APKs for different devices.

4. Can I publish an Android application without testing?

You should test your application before release. In addition, eligible newer personal developer accounts must complete Google's mandatory closed-testing requirements before applying for production access.

5. Can I update my application after publishing?

Yes. You can upload a new signed app bundle with a higher version code and submit it as an application update.

6. How long does Google Play review take?

Review time varies depending on the application and the review process. Google does not guarantee a fixed approval time for every submission.

7. Can I publish a free application?

Yes. You can choose whether your application is free or paid during the Play Console setup process. Monetization features may require additional payment and policy configuration.