Publish Your Android App on Google Play Store — WordsByEkta🌿
How to Publish Your Android App on Google Play Store — Complete Step-by-Step Guide
Everything you need to know: from signing your APK to surviving closed testing. Written from real first-time experience, including every warning, every confusion, and exactly what to do about it.
What You Actually Need
Before touching Play Console, make sure you have these ready. Missing any one of these will block you at some point during the process.
- 1
A completed Android app — built in Android Studio (Kotlin or Java), fully tested on a real device. Not just working on emulator.
- 2
A signed release APK or AAB — you must generate a keystore (.jks file) and sign your build. Keep this keystore file safe — losing it means you can never update the app on Play Store.
- 3
A Google account — this will be your developer account. Use a Gmail you intend to keep permanently.
- 4
$25 one-time fee — Google charges this to register as a developer. It covers unlimited apps forever. No annual renewal.
- 5
A privacy policy URL — required for all apps. Can be hosted on a free Blogger page. Must accurately describe what data your app collects.
- 6
Screenshots — minimum 2, maximum 8. Take them on a real device. PNG or JPEG. For promotion eligibility, at least 4 screenshots with minimum 1080px on each side.
- 7
App icon at 512×512px — PNG or JPEG, under 1MB. This appears on the Play Store listing.
- 8
Feature graphic at 1024×500px — PNG or JPEG, under 15MB. This is the banner shown at the top of your Play Store listing. Required.
Setting Up Google AdMob
If your app will show ads, AdMob must be set up before you write a single line of ad code. You cannot get Ad Unit IDs without first creating the app inside AdMob — and you cannot get Ad Unit IDs without an AdMob App ID. The order matters.
Step 1 — Create Your App in AdMob
- 1
Go to admob.google.com and sign in with your Google account.
- 2
Click Apps → Add app.
- 3
Select Android as the platform.
- 4
When asked "Is the app listed on a supported app store?" — select No if your app is not yet published. You can link it to Play Store later.
- 5
Enter your app name (same as what you plan to use on Play Store).
- 6
Click Add app. AdMob will generate your AdMob App ID.
- 7
Copy your AdMob App ID — it looks like this:
ca-app-pub-XXXXXXXXXXXXXXXX~XXXXXXXXXX
Step 2 — Add AdMob SDK to Your App
- 1
In Android Studio, open your build.gradle (app level) file and add the AdMob dependency inside dependencies:
Latest version is 25.2.0. Version 25.0.0 introduced breaking changes — always check the AdMob release notes before updating.
- 2
Open your AndroidManifest.xml and add your AdMob App ID inside the <application> tag:
Step 3 — Create Ad Units and Get Ad Unit IDs
- 1
In AdMob, go to your app → Ad units → Add ad unit.
- 2
Choose your ad format — Banner for a small bar, Interstitial for a full screen ad, or Rewarded for watch-to-earn ads.
- 3
Give it a name (e.g. "Home Banner", "Level Complete Interstitial") and click Create ad unit.
- 4
Copy your Ad Unit ID — it looks like:
ca-app-pub-XXXXXXXXXXXXXXXX/XXXXXXXXXX - 5
Use this Ad Unit ID in your app code wherever you load that specific ad.
Step 4 — Use Test Ad Unit IDs During Development
During development, never use your real Ad Unit IDs. Google provides official test IDs that are safe to use while building and testing your app. Switch to your real IDs only in the release build.
Step 5 — Ads Will Show in Test Mode Until App is Live
AdMob setup summary
- Create app in AdMob first → get App ID → add to AndroidManifest.xml.
- Then create Ad Units → get Ad Unit IDs → use in your app code.
- App ID has a ~ tilde. Ad Unit ID has a / slash. Never mix them up.
- Use Google's test Ad Unit IDs during development. Switch to real ones for release.
- Test ads showing = everything is working correctly. Real ads come after publishing.
- Never click your own ads. Tell your testers the same.
- After publishing, link your Play Store listing inside AdMob to activate live ads.
Adding Firebase Analytics
Firebase Analytics is free and takes about 15 minutes to set up. It is technically optional — your app will work perfectly without it. But there is one reason every app owner should add it from day one:
What Firebase Analytics gives you for free
- →
Install counts — how many people installed your app and when.
- →
Active users — daily, weekly, monthly active users.
- →
Retention — how many users come back after day 1, day 7, day 30.
- →
Crash reports — if you also add Firebase Crashlytics (also free).
- →
Device and country breakdown — where your users are and what devices they use.
- →
Screen views — which screens users visit most and least.
Step 1 — Create a Firebase Project
- 1
Go to console.firebase.google.com and sign in.
- 2
Click Add project and enter your project name.
- 3
When asked about Google Analytics — select Enable Google Analytics. This is what powers Firebase Analytics.
- 4
Select or create a Google Analytics account and click Create project.
Step 2 — Add Your Android App to Firebase
- 1
On your Firebase project dashboard, click the Android icon to add an Android app.
- 2
Enter your app's package name exactly as it appears in your AndroidManifest.xml (e.g. com.yourname.appname).
- 3
Enter your app nickname (optional) and click Register app.
- 4
Download the google-services.json file that Firebase generates.
- 5
In Android Studio, switch the file view from Android to Project view. Copy google-services.json into the app/ folder (same level as your build.gradle app file).
Step 3 — Add Firebase to Your build.gradle Files
You need to edit two build.gradle files — the project level one and the app level one.
In your project-level build.gradle, add inside the plugins block:
In your app-level build.gradle, add inside the plugins block:
Then add Firebase dependencies inside the dependencies block:
If you also want crash reports, add Crashlytics too:
- 6
Click Sync Now in Android Studio after saving build.gradle. Firebase is now integrated.
Step 4 — Where to See Your Data
- 1
Go to console.firebase.google.com → your project → Analytics → Dashboard.
- 2
Data takes 24–48 hours to appear after first installs. The realtime view shows activity within the last 30 minutes.
- 3
For deeper reports, connect Firebase to Google Analytics (done automatically if you enabled it during setup) and view them at analytics.google.com.
Firebase Analytics summary
- Completely free. No usage limits for basic analytics.
- Add it before your first release — you cannot recover past data.
- google-services.json goes in the app/ folder, not the project root.
- No extra code needed — installs, sessions, and screen views are tracked automatically.
- Data appears in Firebase console within 24–48 hours of first installs.
- Add Crashlytics at the same time — it is also free and gives you automatic crash reports.
Creating Your Google Play Developer Account
- 1
Go to play.google.com/console and sign in with your Google account.
- 2
Click Get started and fill in your developer profile — name, email, phone number.
- 3
Pay the $25 one-time registration fee via card or UPI.
- 4
Your account goes under review — this usually takes a few hours to 1-3 days. You will receive an email when approved.
Registering Your Package Name
If your app has already been shared (via WhatsApp, APKPure, or any direct APK distribution), Google may have already seen your package name on Android devices. In that case, you need to prove ownership before creating your app listing.
- 1
In Play Console, go to Android Developer Verification → your package name will show. Click to register ownership.
- 2
You'll be asked to provide your SHA-256 certificate fingerprint. This comes from your keystore file.
- 3
To get your SHA-256, find your keytool. On Windows, first locate it:
Then run this with your actual keystore path and filename:
- 4
Look for the line starting with SHA256: in the output. Copy that entire fingerprint value.
- 5
Paste it in the Play Console search box. Your key will appear — select it to confirm ownership.
- 6
Google then asks you to prove ownership via APK. Download the token snippet (a string like DC6KHEB45JCS...) shown on screen.
- 7
In Android Studio, go to your project's app/src/main/assets/ folder. If assets folder doesn't exist, create it: right-click main → New → Directory → name it assets.
- 8
Inside assets, create a new file named exactly: adi-registration.properties
- 9
Paste the token snippet inside this file and save.
- 10
Build a signed release APK (not AAB) using your original keystore.
- 11
Upload this APK to Play Console. If your keystore matches, you'll see a green tick — ownership verified.
- 12
Important: After ownership verification, delete adi-registration.properties from your assets folder before building your final AAB. This file is only for verification — it should not be in your published app.
Creating the App in Play Console
- 1
On your Play Console dashboard, click Create app.
- 2
Enter your app name — this is what users will see on Play Store.
- 3
If your app was already registered in Phase 2, paste your package name (e.g. com.yourname.appname). You'll see a green confirmation that it's already registered to your account.
- 4
Select Default language — choose English (en-IN) for India-focused apps, or English (en-US) for global reach.
- 5
Select Free or Paid. Note: once you set an app as Free, you can never change it to Paid. You can add in-app purchases to a free app.
- 6
Select App (not Game) unless you're publishing a game.
- 7
Tick all three declarations (Developer Program Policies, Play App Signing, US Export Laws) and click Create app.
You'll land on the app dashboard with a checklist. The main areas to complete are: App Content, Store Listing, and Releases.
App Content — Filling Every Required Section
This is the longest phase. Go to Dashboard → View tasks → "Provide app information". Work through each section below.
Privacy Policy
Paste your privacy policy URL. This must be a real, publicly accessible page. It must accurately describe what your app collects. If you use AdMob, your privacy policy must mention that Google AdMob may collect Device ID and approximate location for ad personalisation, and link to Google's privacy policy.
App Access
For most apps: select All functionality is available without restrictions. Only choose the other option if your app requires login credentials to review.
Ads
If you have AdMob or any other ad network integrated, select Yes, my app contains ads. This adds a "Contains ads" label on your Play Store listing — it's required by policy and builds user trust.
Content Rating
Click Start questionnaire. Select All Other App Types (unless your app is a game or social/communication app). Answer all questions honestly. Most utility apps will get an Everyone / 3+ rating worldwide — which is what you want.
Target Audience
Select your target age groups. If your app is for adults, select 18 and over. This is important if you have AdMob — apps targeting children under 13 have strict ad policy restrictions that limit AdMob revenue significantly.
Data Safety
This is the most detailed section. Answer based on what your app and its third-party SDKs actually collect. If you use AdMob, you must declare the following even though you didn't personally write the collection code — the SDK is part of your app:
- 1
Does your app collect data? — Yes (AdMob collects data)
- 2
Is data encrypted in transit? — Yes (AdMob uses HTTPS)
- 3
Account creation? — My app does not allow users to create accounts
- 4
Data types — Location: Check Approximate location. Collected + Shared. Not ephemerally. Optional (users can opt out via Android Settings). Purpose: Advertising and Personalization.
- 5
Data types — App info and performance: Check Crash logs and Diagnostics. Collected only. Not ephemerally. Required. Purpose: Analytics.
- 5B
App info and performance (Firebase): If you added Firebase Analytics, also check Diagnostics. Collected only. Not ephemerally. Required. Purpose: Analytics.
- 5C
App info and performance (Crashlytics): If you added Firebase Crashlytics, also check Crash logs. Collected only. Not ephemerally. Required. Purpose: Analytics.
- 5D
App activity (Firebase Analytics): Check App interactions. Collected only. Not ephemerally. Optional. Purpose: Analytics. Only tick In-app search history if your app has a search feature.
- 6
Data types — Device or other IDs: Check Device or other IDs. Collected + Shared. Not ephemerally. Optional. Purpose: Analytics, Advertising, Personalization.
- 7
Data deletion: Select No — you don't collect data on your servers so there's nothing for you to delete remotely. AdMob data deletion is Google's responsibility.
Government Apps, Financial Features, Health Apps
For most apps these are simple:
- →
Government apps: Select No unless you're building for a government entity.
- →
Financial features: Select "My app doesn't provide any financial features" unless your app does stock trading, payments, lending, etc.
- →
Health apps: Select "My app does not have any health features" unless your app tracks fitness, health data, or medical information. A meditation or chanting app is not a health app.
Store Settings — Category, Tags and Contact
- 1
Go to Grow users → Store presence → Store settings.
- 2
Under App category, select App (not Game). Then choose the most accurate category. Common choices: Lifestyle, Tools, Education, Health & Fitness, Music & Audio, Productivity. Pick what your users would search under — not the most technical category.
- 3
Under Tags (up to 5 allowed) — add tags that describe your app's functionality. Tags affect where your app appears in Play Store discovery. Search for relevant terms in the tag manager and add all that apply.
- 4
Under Store listing contact details: add your developer email, optional phone number, and your website or blog URL. This is shown publicly on your Play Store listing.
- 5
External marketing — leave "Advertise my app outside of Google Play" ticked. This is free — Google may show your app in promotional placements at their own cost.
AdMob app-ads.txt Setup
If your app uses Google AdMob, you should create an app-ads.txt file on your developer website. This tells advertisers which ad networks are authorised to sell ads for your app.
Your app-ads.txt file should contain a line like this:
The file must be publicly available at:
In Google Play Console, set your app's Website field to the root website URL:
AdMob will automatically crawl and verify the file. This usually takes 24-48 hours.
Important things to remember
- Publisher ID is not the same as App ID or Ad Unit ID.
- The Publisher ID looks like pub-1234567890123456.
- Privacy Policy URL is separate from Website URL.
- Blogger cannot directly host /app-ads.txt at the root path.
- Google Drive public links will not work for app-ads.txt verification.
- GitHub Pages can host app-ads.txt for free.
If You Do Not Have a Custom Domain
If you do not have your own website or custom domain, you can use GitHub Pages for free to host your app-ads.txt file.
AdMob needs the file to open exactly like this:
If your Play Store website is a Blogger URL, Google Drive link, or any page where you cannot create /app-ads.txt, AdMob may not verify it correctly.
Free Method: Host app-ads.txt on GitHub Pages
-
1
Get your AdMob Publisher ID — go to AdMob → Settings → Account information → Publisher ID. It looks like pub-1234567890123456. Do not use App ID or Ad Unit ID here.
-
2
Create a GitHub Pages repository — login to GitHub, click New repository, and name it exactly yourgithubusername.github.io. Example: myname.github.io.
-
3
Make the repository Public — GitHub Pages must be publicly accessible so AdMob can crawl the file.
-
4
Create the app-ads.txt file — click Add file → Create new file. Name the file exactly app-ads.txt.
-
5
Paste your AdMob line — add your real Publisher ID in this format:
Example:
-
6
Commit the file — click Commit changes. Your repository can contain only this one file. You do not need app code, HTML pages, or a privacy policy in this repository.
-
7
Test the file — open https://yourgithubusername.github.io/app-ads.txt in your browser. You should see your google.com, pub-... line as plain text.
-
8
Add the website in Play Console — go to Google Play Console → Your app → Store presence → Store settings. Under Store listing contact details, edit the Website field.
-
9
Paste the root GitHub Pages URL — add only https://yourgithubusername.github.io. Do not add /app-ads.txt in Play Console.
-
10
Wait for AdMob — AdMob will crawl the file automatically. It usually takes 24-48 hours, so do not keep changing the URL again and again.
| Item | Correct Setup |
|---|---|
| GitHub repository name | yourgithubusername.github.io |
| File name | app-ads.txt |
| File URL | https://yourgithubusername.github.io/app-ads.txt |
| Play Console Website field | https://yourgithubusername.github.io |
| Privacy Policy URL | Can stay separate, such as Blogger |
For future apps
- You can use the same GitHub Pages website for future apps.
- Each future app should use the same Website URL in Play Console if you want the same app-ads.txt file to cover it.
- If all apps use the same AdMob Publisher ID, one Google line is usually enough.
- If you use another ad network, add that network's app-ads.txt line to the same file.
- If you use a different AdMob Publisher ID, add another Google line with that Publisher ID.
Store Listing — Description, Graphics and Screenshots
Go to Grow users → Store presence → Store listings → Default store listing.
Text Content
- 1
App name (30 chars max) — already set when you created the app. Can edit here.
- 2
Short description (80 chars max) — this is the first thing users read. Make it clear and benefit-focused. Example: "Digital mala counter for daily jaap, chanting and streak tracking."
- 3
Full description (4000 chars max) — structure this clearly: app overview, list of features (use bullet points), who it's for, closing line. Include keywords your users would search for. Do not keyword-stuff — write naturally but include important terms.
Graphics
- 4
App icon — upload your 512×512px PNG or JPEG. This is required. Ensure it looks good at small sizes as it will appear in search results and on device home screens.
- 5
Feature graphic — upload your 1024×500px banner. This is required. It appears at the top of your Play Store listing. You can generate this using AI image tools (DALL-E, Midjourney) and resize using a Python script or Canva.
- 6
Screenshots — upload 2-8 phone screenshots (9:16 ratio, 320-3840px per side). For promotion eligibility, include at least 4 screenshots at minimum 1080px per side. Upload in the order you want users to see them — lead with your most compelling screen.
Video (Optional)
You can add a YouTube URL for a demo video. The video must be public or unlisted, ads must be turned off, and it must not be age-restricted. This is entirely optional and can be added later.
Building and Uploading the AAB
Google Play requires AAB (Android App Bundle) format for new apps, not APK. The AAB is a more efficient format that allows Google to deliver optimised APKs to each device.
Building the AAB in Android Studio
- 1
In Android Studio: Build → Generate Signed Bundle / APK
- 2
Select Android App Bundle (not APK)
- 3
Choose your existing keystore file and enter your keystore password, key alias, and key password
- 4
Select Release build variant
- 5
Click Finish — the .aab file will be created in your project's release folder
Uploading to Play Console
- 6
Go to Test and release → Testing → Internal testing → Create new release
- 7
Click Upload and select your .aab file
- 8
Enter a Release name (e.g. 1.0.0) — this is internal only, not shown to users
- 9
Add Release notes — brief description of what this version includes. Required even for internal testing.
- 10
You may see a warning: "No deobfuscation file associated" — this is a normal warning for apps that don't use Proguard/R8. You can ignore it for basic apps.
- 11
Click Next → Preview and confirm → Start rollout
Testing Tracks and Getting to Production
For new developer accounts, Google now requires you to complete a closed test before you can apply for Production (public listing). This is an anti-spam measure — not a reflection of app quality.
Internal Testing
Internal testing is optional but recommended first. Up to 100 testers, available within seconds of upload, no review needed. Good for quick device checks before sharing more widely.
Closed Testing (Required for Production)
- 1
Go to Testing → Closed testing → Manage track → Create new release
- 2
Upload your AAB or add from library if already uploaded
- 3
Go to Testers tab → Create email list → Add tester emails → Save
- 4
Add at least 12 testers — these are real people with Gmail accounts who will install and use the app
- 5
Share the generated tester invite link with your testers
- 6
Testers must click the link, opt in, then install from Play Store (not APK)
- 7
Run the closed test for at least 14 days with 12+ opted-in testers
- 8
After 14 days, return to Dashboard → Production → Apply for production access
Post Publishing Checklist
Your app is live on Play Store — but you are not done yet. There are three important things to do immediately after your app goes live that most guides never mention.
Step 1 — Link Your App to Play Store Inside AdMob
This is the single most important post-publishing step for any app with AdMob. Until you do this, your ads will keep showing in test mode regardless of how long you wait.
- 1
Go to admob.google.com → Apps → your app.
- 2
Look for the Link to Play Store option.
- 3
AdMob will show you two options — Create new app or Link to existing app.
- 4
You must click Link to existing app. Search your package name and select your app from the results.
- 5
Confirm the linking. AdMob will now recognise your app as a verified Play Store app.
Step 2 — Verify Firebase Analytics is Receiving Data
- 1
Go to console.firebase.google.com → your project → Analytics → Realtime.
- 2
Install your app from Play Store on a real device and open it.
- 3
Within a few minutes you should see 1 user in last 30 minutes appear in the Realtime view.
- 4
If you see activity — Firebase is working correctly. Full dashboard data takes 24–48 hours to populate.
- 5
If you see nothing after 10 minutes — double check that google-services.json is in the correct app/ folder and that your build.gradle changes were saved and synced correctly.
Step 3 — Set Up app-ads.txt
Now that your app is live and your Play Store listing has a Website URL, AdMob will begin crawling for your app-ads.txt file. If you followed Phase 5A and set up GitHub Pages already, this will happen automatically. If you have not done it yet, now is the time — see Phase 5A for the complete steps.
Post publishing checklist
- Go to AdMob → Link to Play Store → always choose Link to existing app, never Create new app.
- Live ads take 24–48 hours to appear after linking. This is normal.
- Verify Firebase Analytics by checking Realtime view after installing from Play Store.
- app-ads.txt verification happens automatically if Play Console Website URL is set correctly.
- Check back on AdMob after 48 hours — if ads are still showing as test mode, re-verify the Play Store linking step.
- Share your Play Store link everywhere now — every install from day one is tracked by Firebase.
What Stays the Same vs What Changes for Your Next App
The $25 covers unlimited apps on one developer account. Once you've done this once, future apps are much faster. Here's what you'll need to redo vs what you can skip.
Same Every Time
- Play Console account (already paid)
- AAB upload process
- Internal and closed testing flow
- Data safety questionnaire structure
- Content rating questionnaire
- Release notes format
- Tester invite process
- Play App Signing setup
- Store settings navigation
Changes Per App
- App name and package name
- Icon and feature graphic
- Screenshots
- Short and full description
- Category and tags
- Privacy policy content
- Ads declaration (yes/no)
- Data types declared (if no AdMob)
- Target audience (if children's app)
- Health/financial features declarations
- Keystore (new app = new keystore recommended)
Declarations That Change Based on App Type
| App Type | Ads | Target Audience | Data Safety | Health Section |
|---|---|---|---|---|
| Utility app with AdMob | Yes — contains ads | 18+ or all ages | Declare Device ID, Location, Crash logs | No health features |
| Paid app, no ads | No ads | Depends on content | Declare only what your code collects | No health features |
| Children's app | Restricted ads only | Must include under 13 | Very strict — minimal collection | Depends on features |
| Fitness tracker | Depends | 18+ typically | Declare health data types | Select relevant features |
| No analytics, no ads | No ads | Depends | May be able to say No to data collection | No health features |
The Things Nobody Tells You
What first-time publishers get wrong
- Building the app is easier than deploying it. Google Play has many compliance, policy, and testing layers that don't exist when you're just installing APKs manually.
- The $25 is for the developer account — not per app. Your second, third, and tenth app all use the same account at no extra cost.
- Closed testing with 12 testers for 14 days is mandatory for new developer accounts before production. This is not optional and not waivable.
- The same AAB version code cannot be uploaded twice. Always increment versionCode in build.gradle before rebuilding if you need to resubmit. However, you don't need a new upload for every next step — you can reuse the AAB you already uploaded in a previous step. Just click Browse instead of Upload; the Upload option will ask for a higher version code, but Browse lets you select the already-uploaded build.
- Tester Gmail on the invite list must match the active Play Store account on their phone — not just their browser login.
- AdMob data must be declared in Data Safety even though you didn't write the collection code. The SDK is part of your app by Google's definition.
- Icons and app names on Play Store don't appear instantly after upload. Metadata propagation can take 15-30 minutes. This is normal.
- The "No deobfuscation file" warning is normal for apps not using code obfuscation. Ignore it unless you use Proguard/R8.
- AdMob will serve limited or test-mode ads until your app is live on an approved store and linked in the AdMob console. Full ad revenue only starts after Play Store publishing.
- Keep your keystore .jks file in at least three locations. Losing it means starting a new app listing entirely — you cannot push updates to the same listing without the original signing key.
Comments
Post a Comment