Skip to content
Tutorials Center
My learning

Topics

Lesson 89 of 104 ยท Shipping to Users

Publishing on Google Play

Publish on Google Play: developer account, store listing, data safety form, testing tracks, staged rollouts, policies, crash reporting and Android vitals explained step by step.

You have a signed, tested App Bundle. The last step between your code and your users is the Google Play Console, the web dashboard where you create the app, describe it, answer policy questions, choose who gets which version, and watch how it behaves in the wild. The code part is over, but this part has its own traps: a missing form can block a release, an unreviewed policy declaration can get an update rejected, and a rollout to everyone at once can turn one bug into a one-star review wave.

This lesson walks through the whole path: the developer account, the store listing, the data safety form and other declarations, the testing tracks, staged rollouts, the policies that matter most, and crash reporting with Android vitals. It follows Signing and Release Builds. The Play Console is a website, so there is nothing to run here: the steps are read-only descriptions of what you do in the console. The TryIt blocks are plain-Kotlin stand-ins that model two things you must do by hand anyway: validating store-listing limits and deciding whether to continue or halt a staged rollout. Console screens and policy details change often, so use this lesson for the concepts and always confirm the exact current wording and numbers in the Play Console help.

The developer account

To publish you need a Google Play developer account. You register with a Google account, accept the developer agreement, pay a one-time registration fee (25 US dollars at the time of writing) and verify your identity. You choose between two types:

  • A personal account for an individual.
  • An organization account for a company, which requires a business identity such as a D-U-N-S number and verification of the organization.

Verification can take days, so do it well before you plan to launch. Personal accounts also have an extra requirement that applies to newly created accounts: before you can publish to production, you must run a closed test with a minimum number of testers who stay opted in for a minimum number of days. At the time of writing that number is twelve testers for fourteen days, but the figures have changed before, so check the current rule. Organization accounts are not subject to it. Plan your first release around this waiting period.

If you plan to earn money, a merchant account (payments profile) is linked for paid apps, subscriptions and in-app purchases. The service fee and the tax setup depend on your country and program, so read the current terms before you design a pricing model.

Creating the app

In the console you choose Create app and fill in a short form: the default app name, language, whether it is an app or a game, free or paid, and confirmations about policies and export laws. The app's package name (the applicationId) is permanent. It becomes the app's identity in the store, and you cannot change it after you publish, so choose it deliberately (see Gradle for Android).

From then on, the console shows a dashboard checklist of everything required before you can publish. Treat it as a to-do list: nothing goes live until each item is complete.

The store listing

The main store listing is your shop window, and it is also what Play search indexes. You provide:

Item Notes
App name Up to 30 characters
Short description Up to 80 characters; shown first in many places
Full description Up to 4,000 characters; explain real features honestly
App icon 512 by 512 px PNG
Feature graphic 1,024 by 500 px banner
Screenshots At least two for phones; add tablet and wear images if you support them
Optional Promo video link, category, tags, contact email, website, privacy policy URL

Write for people first and search second. Use the words users would type, but never stuff keywords, name competitors or claim features you do not have: misleading metadata is a policy violation and can get your listing suspended. Screenshots should show the actual app. You can create custom store listings for different countries or campaigns, and translate the listing into each language you support (see Accessibility and Localization); apps that are localized convert better.

Checking a listing against the limits

The console rejects a listing that exceeds a field limit, but a script can catch it earlier, for instance in a CI step that checks your store text files. This stand-in validates the character limits from the table above. It is a model, not an official validation, so confirm the current limits in the console.

Kotlin Store listing validator (stand-in)

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with readln()), it gets the next line from this box.

The second listing breaks three rules at once: the name is far over 30 characters, the short description is empty and the full text is 100 characters over. Counting code points rather than String.length matters when a listing contains emoji, which occupy two UTF-16 units each.

Declarations: data safety, content rating and more

Before you can publish, you must complete several App content declarations. They are not decoration: users see some of them on your store page, and Play can remove apps whose answers do not match what the app really does.

  • Privacy policy. A public URL describing what you collect and how you use it. It is required for essentially every app, and mandatory if the app handles personal or sensitive data.
  • Data safety form. You declare what user data the app and its libraries collect or share (location, contacts, identifiers, financial info, and so on), why, whether it is optional, whether it is encrypted in transit, and whether users can request deletion. Your answers appear in a "Data safety" section on the listing. Include the data your third-party SDKs collect, such as analytics, ads and crash reporting. Mismatches between the form and real behavior are a common reason for rejection.
  • Content rating. An International Age Rating Coalition questionnaire about violence, user-generated content and similar topics; it produces ratings for each region.
  • Target audience and content. Which age groups the app targets. If children are included, the Families policy applies, with stricter rules on ads, data and SDKs.
  • Ads declaration, government app and financial features declarations, and for some apps a news app declaration.
  • Permission declarations. Sensitive permissions such as background location, SMS, call logs, or "all files access" need a form explaining the core feature that requires them, and may need a short video. Request the minimum permissions (see Runtime Permissions) and prefer alternatives such as the photo picker, which avoid a declaration altogether.
  • Account deletion. If users can create an account in your app, you must provide an in-app path and a web path to request deletion of the account and its data.

Keep these answers in one internal document that you update whenever you add an SDK or a feature, so the next release does not stall on a forgotten form.

Release tracks

You do not publish straight to everyone. A track is a channel for a release, and a release goes through them in order of audience size:

flowchart LR
    A["Internal testing<br/>up to 100 testers<br/>available within minutes"] --> B["Closed testing<br/>invited testers or groups"]
    B --> C["Open testing<br/>anyone can opt in"]
    C --> D["Production<br/>everyone on Play"]

A release moves from small trusted groups toward all users, collecting feedback and crash data at each step.

  • Internal testing is for your team: up to 100 testers added by email, quick to publish, ideal for every build you want to try from the real Play install flow.
  • Closed testing is for a larger invited group, defined by email lists or Google Groups. You can run several closed tracks (alpha, beta, a partner group). It is also where new personal accounts meet the production-access requirement.
  • Open testing lets anyone opt in from your store page, useful for a public beta. The app appears with a "beta" label.
  • Production is the public release.

In each track you create a release: upload the AAB, write release notes per language, and review it. The same artifact (same versionCode) can be promoted from one track to the next, so what you tested is exactly what you ship. Google runs pre-launch reports on test builds, which install the app on real devices in Firebase Test Lab and crawl it, reporting crashes and accessibility issues. Your first production release also goes through a review, which can take longer than later updates; submit early.

Staged rollouts

For a production release you choose a rollout percentage instead of 100%. For example, 5% of eligible users receive the update; if the numbers look healthy you raise it to 20%, 50%, then 100%. If something is wrong you halt the rollout, which stops new users from receiving the build while you investigate.

Two facts shape your plan:

  • You cannot roll back to an older versionCode. Users who already updated keep the new version. The fix for a bad release is to halt, fix the bug, and publish a new, higher versionCode (see Signing and Release Builds).
  • Staged rollouts only help if you watch the data. A 5% rollout means 5% of your crashes, and the point is to notice them before the other 95% are affected.

You can also use the in-app updates API to prompt users to update (flexible or immediate flows) when a critical fix is out, and the in-app review API to ask for a rating at a good moment without leaving the app. Do not ask right after an error or on first launch.

Deciding on a rollout, modeled

This stand-in plays out a staged rollout over several days against a crash-rate threshold. At each stage it compares the new version's crash rate with a limit and either expands the rollout or halts it. It models the decision logic, which you apply by hand in the console; the numbers are invented.

Kotlin Staged rollout with a crash-rate gate (stand-in)

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with readln()), it gets the next line from this box.

In the second run the 20% stage already exceeds the limit, so the rollout stops after affecting a fifth of the audience instead of everyone. That is the entire value of staging.

Policies that catch developers

Google Play's Developer Program Policies are long, and breaking them can mean a rejected update, a removed app or a suspended account. The ones that cause the most trouble:

  • User data and privacy: transparency about collection, a working privacy policy, secure handling, and the data safety form matching reality.
  • Permissions and APIs that access sensitive data: restricted permissions need an approved use case.
  • Deceptive behavior: misleading listing text, fake reviews, impersonating another app or developer, hidden functionality.
  • Intellectual property and spam: do not copy other apps' content or names, and do not publish many near-identical apps.
  • Monetization and ads: ads must not mimic system UI or appear out of context, subscription terms must be clear, and apps selling digital goods generally must use Google Play's billing system.
  • Target API level: new apps and updates must target a recent Android API level by a deadline Google announces each year; apps that do not can become unavailable to newer devices. Update targetSdk regularly (see Gradle for Android).
  • Families: apps for children must follow additional rules about data, ads and SDKs.
  • Malware and unwanted software: never include code that behaves differently when reviewed.

Read the policy center before your first release and subscribe to policy update emails. If a review rejects your app, the email states the reason and the fix; correct the issue and submit the update rather than arguing in circles.

Crash reporting and Android vitals

After launch your job is to find problems before reviews do. Play collects a set of quality metrics from opted-in devices and shows them under Android vitals in the console:

  • Crash rate and ANR (application not responding) rate, both as the percentage of daily active users who experienced one. Google defines "bad behavior thresholds" (at the time of writing roughly 1.09% of daily active users for crashes and 0.47% for ANRs, with a stricter per-device-model threshold). Exceeding them can reduce your app's visibility in search and recommendations.
  • Startup time, slow rendering and frozen frames, which tie back to Performance and Profiling.
  • Excessive wake-ups, stuck wake locks and background battery use.
  • Breakdowns by app version, Android version and device model, so you can see that a crash occurs only on one manufacturer's phones.

Crash clusters in the console include a deobfuscated stack trace when your AAB contained the R8 mapping file, which is why you keep and upload it. For richer reporting, many teams add Firebase Crashlytics, which groups crashes, shows breadcrumbs and custom keys (user flow, feature flags), reports non-fatal errors you record yourself, and can alert you in real time. Whichever tool you use, link it to your issue tracker, add a version tag to every report, and check the dashboard after every rollout step.

Also read your ratings and reviews (you can reply publicly), use pre-launch reports for each release, and consider release notes that actually say what changed. A steady cycle of small releases with staged rollouts and vitals checks is how successful apps keep their rating up.

Other stores: Amazon Appstore and alternatives

Google Play is the main store, but the same app can often reach more users elsewhere. The Amazon Appstore serves Fire tablets, Fire TV and, on supported devices, Android apps. Publishing is free and follows a similar path:

  1. Create a free Amazon developer account and register the app in the developer console.
  2. Check compatibility: Fire devices have no Google Play services. Anything that depends on them (Firebase Cloud Messaging, Google Maps, Play billing, Google Sign-In) needs an alternative or a feature check. Amazon offers its own messaging and in-app purchasing APIs.
  3. Upload the build (APK; check Amazon's current rules for app bundles), fill in the listing (title, descriptions, screenshots, icon, content rating, privacy policy) and choose the supported devices.
  4. Submit for review. Amazon tests the app on its devices and checks for malware and policy compliance.

Other stores worth knowing: Samsung Galaxy Store, Huawei AppGallery (no Google services), Xiaomi GetApps and F-Droid for open-source apps. Each has its own signing rules, billing system and review process. The engineering approach is the same for all of them: keep store-specific code behind an interface, use build flavors per store (productFlavors) and test on a device that matches the store's hardware (Gradle for Android).

A launch checklist

  1. Developer account verified; production-access requirement satisfied if it applies.
  2. App created; listing text, icon, feature graphic and screenshots complete in each language.
  3. Privacy policy, data safety, content rating, target audience, ads and permission declarations done.
  4. Signed AAB with a new versionCode on the internal track, then closed testing.
  5. Pre-launch report reviewed; crash-free on real devices.
  6. Production release at a small percentage, release notes written.
  7. Vitals and crash dashboards checked daily; roll forward in stages or halt.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. Which track should you use to get a new build to your own team within minutes?

    Internal testing supports up to about a hundred testers and publishes quickly, so it is the right first stop for every build.
  2. 2. A staged rollout at 20% shows a crash spike. What is the correct response?

    You cannot roll back installed users to an older code. Halting stops further spread, and a higher versionCode carries the fix.
  3. 3. Your app contains a third-party analytics SDK that collects a device identifier. What must the data safety form say?

    You are responsible for everything your app collects or shares, including through SDKs. A form that omits it can lead to rejection.
  4. 4. Why should you upload the R8 mapping file (or an AAB that contains it)?

    The mapping translates R8's short names back to your real classes and methods, which makes crash reports usable.
  5. 5. Which statement about the package name (applicationId) is true?

    The applicationId is the app's identity on the device and in the store. Changing it creates a different app.

Summary

  • A Play developer account needs identity verification and a one-time fee; new personal accounts must also complete a closed-test requirement before production, so plan for the waiting time.
  • The package name is permanent; the dashboard checklist lists everything required before you can publish.
  • The store listing has field limits (name, short and full description, icon, feature graphic, screenshots); write honestly, localize it and never mislead.
  • Declarations (privacy policy, data safety including SDK data, content rating, audience, ads, permissions, account deletion) must match what the app really does.
  • Releases move through internal, closed and open testing to production; the same artifact can be promoted.
  • Staged rollouts limit the blast radius; you cannot roll back, you halt and ship a higher versionCode.
  • Follow the policies on data, permissions, deception, monetization, target API level and children.
  • Watch Android vitals (crashes, ANRs, startup, rendering, battery) and use deobfuscated traces or Crashlytics; stay under the bad behavior thresholds.
  • The console steps are read-only here; the TryIts model the listing limits and the rollout decision in plain Kotlin.

Next: CI/CD for Android