Topic 14 of 15 · React Native

Topic 14 : Uploading app to Playstore for android

Lesson TL;DRTopic 14: Uploading App to Play Store for Android 📖 6 min read · 🎯 advanced · 🧭 Prerequisites: firebase, generatingsignedapk Why this matters You've built the app. It runs on your phone, your frien...
6 min read·advanced·react-native · android · play-store · deployment

Topic 14: Uploading App to Play Store for Android

📖 6 min read · 🎯 advanced · 🧭 Prerequisites: firebase, generating-signed-apk

Why this matters

You've built the app. It runs on your phone, your friend's phone, maybe even your cousin's. But right now, the only way to share it is to send an APK file over WhatsApp — and that doesn't feel like a real launch, does it? Here's the thing — getting your app onto the Play Store is what separates a side project from a product that millions of Android users can discover and download. This lesson walks you through the exact steps: signing your app, setting up Google Play Console, and hitting that publish button for the first time.

What You'll Learn

  • Set up a Google Play Developer account and configure the Android build environment
  • Generate a signed release APK using Gradle and a secure keystore
  • Prepare app metadata, icons, and manifest files for production
  • Upload, review, and publish the APK through Google Play Console

The Analogy

Think of shipping an Android app like releasing a physical product through a major retail chain. The keystore is your manufacturer's seal of authenticity — without it, the store won't accept the shipment. Gradle is the production line that assembles and seals the package. The Google Play Console is the store's supplier portal where you submit product details, photos, and the physical units. And "Start rollout to production" is the moment the warehouse loads your product onto trucks headed to every shelf. Skip any step in the chain and the shipment bounces back.

Chapter 1: Prerequisites

Before a single byte reaches the Play Store, two things must be in place.

  1. Google Play Developer Account — Create one at Google Play Console. There is a one-time $25 registration fee. Your account is the identity the store links to every app you publish.
  2. React Native Project — Your project must be complete and tested on a real Android device or emulator. Do not publish a build you haven't run end-to-end.

Chapter 2: Setting Up the Android Environment

Step 1 — Install Android Studio

Download and install Android Studio from https://developer.android.com/studio. Android Studio bundles the build tools and SDK manager you'll need throughout this process.

Step 2 — Configure the Android SDK

  1. Open Android Studio.
  2. Navigate to File › Settings › Appearance & Behavior › System Settings › Android SDK.
  3. Verify that the required SDK platforms and build tools are installed. At minimum you need the platform matching your targetSdkVersion and Android SDK Build-Tools.

Step 3 — Set the ANDROID_HOME Environment Variable

Point your shell to the SDK location so Gradle can find it.

Windows:

set ANDROID_HOME=C:\Users\<Your-Username>\AppData\Local\Android\Sdk

macOS / Linux:

export ANDROID_HOME=~/Library/Android/sdk

Add the export line to your ~/.zshrc or ~/.bash_profile so it persists across sessions.

Chapter 3: Generating a Signed APK

The Play Store requires every APK to be signed with a private key. You'll create the key once and use it for every future release of this app — guard it carefully.

Step 1 — Create a Keystore

keytool -genkey -v -keystore my-release-key.keystore -keyalg RSA -keysize 2048 -validity 10000 -alias my-key-alias

The tool prompts you for your name, organization, and passwords. When it finishes, store my-release-key.keystore somewhere secure and outside version control — losing this file means you can never update your Play Store listing.

Step 2 — Configure Gradle for Signing

Tell Gradle to use the keystore when building a release variant.

android/app/build.gradle:

android {
    ...
    defaultConfig { ... }
    signingConfigs {
        release {
            if (project.hasProperty('MYAPP_RELEASE_STORE_FILE')) {
                storeFile file(MYAPP_RELEASE_STORE_FILE)
                storePassword MYAPP_RELEASE_STORE_PASSWORD
                keyAlias MYAPP_RELEASE_KEY_ALIAS
                keyPassword MYAPP_RELEASE_KEY_PASSWORD
            }
        }
    }
    buildTypes {
        release {
            ...
            signingConfig signingConfigs.release
        }
    }
}

Step 3 — Store Signing Variables in gradle.properties

Never hard-code credentials in build.gradle. Instead, write them to a properties file that stays off of source control.

android/gradle.properties:

MYAPP_RELEASE_STORE_FILE=my-release-key.keystore
MYAPP_RELEASE_KEY_ALIAS=my-key-alias
MYAPP_RELEASE_STORE_PASSWORD=your-store-password
MYAPP_RELEASE_KEY_PASSWORD=your-key-password

Add android/gradle.properties to your .gitignore.

Step 4 — Build the Signed APK

cd android
./gradlew assembleRelease

The signed APK is written to:

android/app/build/outputs/apk/release/app-release.apk

That file is what you'll upload to the Play Store.

Chapter 4: Preparing the App for Release

Step 1 — Update App Information in the Manifest

Confirm the package name and label in AndroidManifest.xml are final before you publish. You cannot change the package name after first submission.

android/app/src/main/AndroidManifest.xml:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.yourappname">
    <application
        android:label="Your App Name"
        android:icon="@mipmap/ic_launcher"
        ...>
        ...
    </application>
</manifest>

android/app/src/main/res/values/strings.xml:

<resources>
    <string name="app_name">Your App Name</string>
</resources>

Step 2 — Create App Icons

Generate launcher icons and drop them into the mipmap density directories under android/app/src/main/res/. The Play Store requires a 512 × 512 px high-resolution icon in the Console separately from the in-app launcher icon.

res/
  mipmap-mdpi/      ic_launcher.png   (48×48)
  mipmap-hdpi/      ic_launcher.png   (72×72)
  mipmap-xhdpi/     ic_launcher.png   (96×96)
  mipmap-xxhdpi/    ic_launcher.png   (144×144)
  mipmap-xxxhdpi/   ic_launcher.png   (192×192)

Chapter 5: Uploading to the Google Play Store

Step 1 — Log In to Google Play Console

Open https://play.google.com/console and sign in with your developer account.

Step 2 — Create a New Application

  1. Click Create app.
  2. Enter the app name, default language, and app type (e.g., App / Free).
  3. Click Create.

Step 3 — Prepare the Store Listing

Fill in every required field before uploading the APK. The Play Store validates this data during review.

  1. App details — Name, full description (up to 4000 characters), and short description (up to 80 characters).
  2. Graphics — Upload at least two screenshots per form factor, a 512 × 512 px high-res icon, and a 1024 × 500 px feature graphic.
  3. Categorization — Select the app category and relevant tags.
  4. Contact details — Provide a support email address; website and phone number are optional but recommended.

Step 4 — Upload the APK

  1. Navigate to the Release section in the left sidebar.
  2. Click Create new release.
  3. Upload app-release.apk (the file generated at android/app/build/outputs/apk/release/app-release.apk).
  4. Fill in the release notes describing what's new, then click Save.

Step 5 — Review and Publish

  1. Review all store listing details and release information.
  2. Click Review release — the Console surfaces any warnings or errors.
  3. Once satisfied, click Start rollout to production.
  4. Click Confirm to publish. Google typically reviews new apps within a few hours to a few days.
flowchart TD
    A[Create Google Play Developer Account] --> B[Install Android Studio + SDK]
    B --> C[Generate Keystore with keytool]
    C --> D[Configure build.gradle signingConfigs]
    D --> E[Set gradle.properties variables]
    E --> F[./gradlew assembleRelease]
    F --> G[Update AndroidManifest.xml + strings.xml]
    G --> H[Add icons to mipmap directories]
    H --> I[Log into Play Console]
    I --> J[Create app + fill Store Listing]
    J --> K[Upload app-release.apk]
    K --> L[Review release → Start rollout to production]
    L --> M[App live on Play Store 🎉]

🧪 Try It Yourself

Task: Run a full release build of your React Native app and inspect the signed APK.

  1. Make sure your android/gradle.properties has valid keystore entries.
  2. From your project root, run:
cd android && ./gradlew assembleRelease
  1. When the build succeeds, verify the output:
ls -lh app/build/outputs/apk/release/app-release.apk

Success criterion: You see app-release.apk listed with a non-zero file size (typically 10–60 MB). Open it with aapt dump badging app/build/outputs/apk/release/app-release.apk and confirm that package: name matches your intended bundle ID and that uses-permission entries look correct.

🔍 Checkpoint Quiz

Q1. Why can't you change the package attribute in AndroidManifest.xml after your app is first published to the Play Store?

Q2. Given this build.gradle snippet, what happens if the property MYAPP_RELEASE_STORE_FILE is not defined in gradle.properties?

signingConfigs {
    release {
        if (project.hasProperty('MYAPP_RELEASE_STORE_FILE')) {
            storeFile file(MYAPP_RELEASE_STORE_FILE)
            storePassword MYAPP_RELEASE_STORE_PASSWORD
            keyAlias MYAPP_RELEASE_KEY_ALIAS
            keyPassword MYAPP_RELEASE_KEY_PASSWORD
        }
    }
}

A) The build fails with a Gradle error
B) The release APK is built unsigned
C) The debug keystore is used automatically
D) Gradle skips the release build type entirely

Q3. Where does ./gradlew assembleRelease write the signed APK?

A) android/release/app-release.apk
B) android/app/build/outputs/apk/release/app-release.apk
C) android/app/outputs/release/app-release.apk
D) android/build/apk/release/app-release.apk

Q4. You've uploaded your APK to the Play Console and clicked "Review release," but the Console shows a warning that your Store Listing is incomplete. Which assets are most likely missing, based on the minimum requirements?

A1. The package name is the permanent, unique identifier that links updates, user reviews, and purchases to your app on the Play Store. Changing it after publication would create an entirely new listing and break existing installs — Google enforces immutability to protect app continuity.

A2. B — The if (project.hasProperty(...)) guard means the block is skipped entirely when the property is absent, leaving the release signing config empty. Gradle then produces an unsigned APK, which the Play Store will reject.

A3. B — android/app/build/outputs/apk/release/app-release.apk is the standard Gradle output path for a release assembly.

A4. The most commonly missing assets are screenshots (at least two per supported form factor) and the feature graphic (1024 × 500 px). The Play Console blocks submission until both are present alongside the high-res icon.

🪞 Recap

  • A Google Play Developer account ($25 one-time fee) is required before you can publish anything.
  • ANDROID_HOME must point to your SDK directory so Gradle can locate build tools.
  • The keystore created with keytool must be stored securely — it cannot be recovered if lost, and you need it for every future update.
  • Signing credentials belong in gradle.properties (gitignored), not hard-coded in build.gradle.
  • ./gradlew assembleRelease produces the signed APK at android/app/build/outputs/apk/release/app-release.apk.
  • The Play Console requires a complete store listing — descriptions, screenshots, feature graphic, and icon — before a release can go to production.

📚 Further Reading

Like this topic? It’s one of 15 in React Native.

Block your seat for ₹2,500 and join the next cohort.

Course detailsBlock your seat →