In this article we going to learn the complete process of deploying an Ionic app to the Google Play Store — from building a production APK/AAB to publishing it live on the store.
Getting your first app on the Play Store feels like a big milestone. And it is. But the process has quite a few steps and if we miss any of them, we end up with a rejected build or a cryptic error in Android Studio. We've seen this happen a lot — developers build a great app, rush the publishing step, and hit walls that could have been avoided.
This guide walks through the entire thing from start to finish. Building the app, signing it with a keystore, generating the AAB file Google requires, creating the Play Store listing, and submitting for review.
This tutorial shows how to:
- Build the Ionic app in production mode
- Generate a signed AAB (Android App Bundle) using Android Studio
- Create a keystore for signing the app
- Set up a Google Play Developer account
- Create a new app listing in Google Play Console
- Upload the AAB and fill in the required store listing details
- Handle common errors before submission
- Publish the app for review
What We Need Before Starting
Before jumping in, make sure these are ready :
- Ionic app with Capacitor set up for Android
- Android Studio installed on our machine
- A Google Play Developer account — one-time registration fee of $25
- App icons and splash screens generated (we need icons in multiple sizes for Play Store)
- At least one screenshot of the app for the store listing
If we haven't set up Capacitor for Android yet, run these first :
ionic build
npx cap add android
npx cap sync android
Step 1 : Build the Ionic App for Production
Before generating the Android build, we need a production build of our Ionic app. Run :
ionic build --configuration production
This generates the www folder with minified, optimized code. After the build completes, sync the updated files to Android :
npx cap sync android
This copies the updated www folder into the Android project. Every time we change our Angular/Ionic code and want those changes in the Android build, we run these two commands.
Open the Android project in Android Studio :
npx cap open android
Wait for Android Studio to finish indexing and Gradle sync. This takes a couple of minutes the first time.
Step 2 : Update App ID and Version
Before building for production, make sure the app ID and version are correct. These can't easily be changed after publishing.
App ID — this is the unique identifier for our app on the Play Store. Something like com.yourcompany.appname. Set it in capacitor.config.ts :
const config: CapacitorConfig = {
appId: 'com.yourcompany.appname',
appName: 'Your App Name',
webDir: 'www'
};
After changing this, run npx cap sync again.
Version code and version name — open android/app/build.gradle in Android Studio. Find the defaultConfig section :
defaultConfig {
applicationId "com.yourcompany.appname"
minSdkVersion 22
targetSdkVersion 34
versionCode 1
versionName "1.0.0"
}
versionCode— an integer that increments with every release. Start at 1. The Play Store uses this to determine if a new version is available. Every upload must have a higher versionCode than the previous one.versionName— the version string shown to users. Something like "1.0.0".
Step 3 : Create a Keystore for Signing
Google Play requires every app to be signed with a digital certificate called a keystore. This proves the app comes from us and not someone else. We create this once and use it for every update we ever publish for this app.
This is critical — if we lose the keystore, we can never update the app on the Play Store. Keep it backed up securely.
Generate the keystore using the keytool command. Run this in the terminal :
keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias my-key-alias
keytool will ask us several questions :
- Keystore password — choose a strong password and remember it
- Key password — can be the same as keystore password
- First and last name — our name or company name
- Organization unit — department name (can leave blank with "Unknown")
- Organization — company name
- City, State, Country code — our location details
After filling everything in, keytool generates my-release-key.jks in the current folder.
Store this file safely — in a password manager, secure cloud storage, or a separate encrypted backup. Never commit it to a public git repository.
Step 4 : Configure Signing in Android Studio
Now tell Android Studio to use our keystore when building.
In Android Studio, go to Build → Generate Signed Bundle / APK.
A dialog opens. Select Android App Bundle (AAB is what Google Play requires now — not APK). Click Next.
On the Key store path screen :
- Click Create new if this is the first time (or Choose existing if we already have a keystore)
- Browse to our
my-release-key.jksfile - Enter the keystore password
- Enter the key alias (
my-key-alias) - Enter the key password
- Click Next
On the next screen :
- Select release as the build variant
- Check both V1 (Jar Signature) and V2 (Full APK Signature)
- Click Create
Android Studio builds the signed AAB. It takes a few minutes. When done, it shows a balloon notification at the bottom. Click locate to find the output file.
The AAB file is at :
android/app/release/app-release.aab
This is the file we upload to Google Play.
Step 5 : Set Up Google Play Developer Account
Go to play.google.com/console and sign in with a Google account.
Click Get started and pay the one-time $25 registration fee. Fill in the developer profile — name, email, phone number. Accept the developer distribution agreement.
Account review typically takes 2-3 days before we can publish apps. The account creation is instant but actual publishing access takes a little time.
Once approved, the Play Console dashboard is available.
Step 6 : Create the App in Play Console
In Play Console, click Create app.
Fill in the details :
- App name — the name users see on the Play Store
- Default language — pick our primary language
- App or game — select App
- Free or paid — Free or Paid (paid requires a Google Payments Merchant account)
Accept the declarations and click Create app.
We land on the app dashboard. On the left menu, there's a checklist under Publish your app. We need to complete all items before the app can go live.
Step 7 : Fill in the Store Listing
Click Store presence → Main store listing in the left menu.
Fill in all required fields :
App details :
- Short description — max 80 characters. This appears below the app name in search results. Make it clear and specific.
- Full description — max 4000 characters. Describe what the app does, key features, who it's for. Use line breaks and bullet points to keep it readable.
Graphics :
- App icon — 512 x 512 PNG, no alpha channel. This is the icon shown on the Play Store listing page (different from the launcher icon inside the app).
- Feature graphic — 1024 x 500 PNG or JPG. The banner shown at the top of the listing.
- Screenshots — minimum 2, maximum 8. PNG or JPG. At least 320px on shortest side. Capture the actual app screens — login, home, main features.
For phone screenshots, minimum size is 320 x 480 px and maximum is 3840 x 3840 px. Landscape or portrait both work.
Click Save after filling everything in.
Step 8 : Complete the App Content Section
Google requires us to answer questions about our app's content. Click Policy → App content in the left menu.
Complete each section :
Privacy policy — paste the URL to our privacy policy page. Every app needs one. If we don't have one, use a privacy policy generator online and host it on a simple page. This is mandatory.
App access — tell Google if the app requires login to review. If it does, provide test account credentials. If our app has a demo mode, mark it as "All or some functionality is restricted" and provide login details.
Ads — does our app show ads? Yes or No.
Content ratings — click Start questionnaire. Answer questions about our app's content — violence, sexual content, gambling etc. Google generates an age rating based on our answers. For most business/utility apps this comes back as "Everyone".
Target audience — who is the app for? If it's for general adults, select 18+. If it targets children, additional requirements apply.
Data safety — this one takes some time. We need to declare exactly what data our app collects, how it's used, whether it's shared with third parties, and whether users can request deletion. Firebase Auth collects email addresses and user IDs — declare those. Be honest and thorough here — Google checks this.
Click Save on each section.
Step 9 : Upload the AAB
Click Release → Production in the left menu. Click Create new release.
On the release page, click Upload and select our app-release.aab file. The upload takes a minute depending on file size.
After uploading, fill in :
- Release name — something like "1.0.0 - Initial Release"
- Release notes — what's in this version. For the first release, something like "Initial release of [App Name]"
Click Save then Review release.
Google runs automated checks on our AAB. If there are any issues — missing permissions, API level problems, manifest errors — they show up here. Fix them and re-upload if needed.
If everything looks clean, click Start rollout to production.
Step 10 : Submit for Review
After starting the rollout, Google reviews the app before it goes live. For first-time apps this takes anywhere from a few hours to a few days. Subsequent updates are usually faster.
We'll get an email when the review is complete. If approved, the app goes live automatically. If rejected, Google tells us exactly what needs to be fixed.
Common rejection reasons :
- Privacy policy URL not working or not covering the app's data practices
- Screenshots don't match actual app content
- App description makes misleading claims
- Data safety section is incomplete or inaccurate
- App crashes during Google's review testing
Common Build Errors
"Keystore file not found"
The path to the keystore in the signing config is wrong. Double check the path and use absolute path if relative isn't working.
"App bundle contains an APK"
We submitted an APK instead of an AAB. Go back to Build → Generate Signed Bundle / APK and select Android App Bundle, not APK.
"Version code already used"
We're trying to upload an AAB with the same versionCode as a previous upload. Increment versionCode in build.gradle and rebuild.
Gradle build fails in Android Studio
Run Build → Clean Project first, then Build → Rebuild Project. If it still fails, check the error in the Build tab at the bottom — it usually points to a specific dependency issue or missing SDK version.
"You need to use a different package name"
The app ID we chose is already taken on the Play Store. Change applicationId in build.gradle and appId in capacitor.config.ts to something unique, then rebuild.
Summary
We learned the complete process of deploying an Ionic app to the Google Play Store. We covered :
- Building the Ionic app in production mode and syncing to Android
- Updating app ID, versionCode, and versionName in build.gradle
- Generating a signed keystore with keytool and backing it up securely
- Creating a signed AAB in Android Studio using Build → Generate Signed Bundle
- Setting up a Google Play Developer account
- Creating the app listing and filling in store description and screenshots
- Completing the App Content section — privacy policy, content rating, data safety
- Uploading the AAB to the Production track
- Submitting for review and what to expect during the review process
- Fixing common errors like wrong versionCode and missing keystore
The first deployment always takes the longest because of all the one-time setup — developer account, keystore, store listing. After that, publishing an update is much faster — increment the versionCode, build a new AAB, upload it, and roll out.
I hope you like this article...
Happy coding! 🚀
0 Comments