Release Your Android App: Signing, Play Store and Interviews

An app is only useful when real people can install it. This lesson shows how a project becomes a release on the Google Play Store, then how to talk about your work in interviews. Steps in Play Console change from time to time, so follow the current on-screen instructions if they differ.

Before you release

• Choose a unique application ID, such as com.yourname.recipes. It cannot be changed after publishing.
• Set versionCode (an integer that must go up with every upload) and versionName (the text users see).
• Replace the default launcher icon with your own.
• Remove test code and logging of private data.
• Test on at least one real phone and one small and one large emulator.

Signing and shrinking

Android requires every app to be signed with a key that proves it comes from you. Keep this key file and its passwords safe and backed up, and never commit them to a public repository. Google Play can manage the final signing key for you (Play App Signing), and you upload with an upload key. A minimised release build uses R8, which removes unused code, shortens names and makes the app smaller and faster.

`app/build.gradle.kts (release settings)`

// app/build.gradle.kts  -> android { ... }
signingConfigs {
    create("release") {
        // Read secrets from gradle.properties or the environment. Never commit the keystore or passwords.
        storeFile = file(providers.gradleProperty("RELEASE_STORE_FILE").get())
        storePassword = providers.gradleProperty("RELEASE_STORE_PASSWORD").get()
        keyAlias = providers.gradleProperty("RELEASE_KEY_ALIAS").get()
        keyPassword = providers.gradleProperty("RELEASE_KEY_PASSWORD").get()
    }
}
buildTypes {
    release {
        isMinifyEnabled = true          // R8 shrinks and obfuscates the code
        isShrinkResources = true        // removes unused resources
        proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
        signingConfig = signingConfigs.getByName("release")
    }
}

1. In Android Studio choose Build > Generate Signed App Bundle or APK.
2. Choose Android App Bundle (AAB). Google Play requires this format for new apps.
3. Create a new keystore, or choose an existing one. Fill in the passwords and alias and save the file somewhere safe.
4. Choose the release build type and finish. Android Studio produces a .aab file.
5. Install the release build on a phone (for example with bundletool, or by uploading to internal testing) and check that nothing broke after shrinking.

Publish on Google Play

1. Create a Google Play developer account. A one-time registration fee applies, and new personal accounts may need to complete testing requirements before a production release. Check the current rules in Play Console.
2. Create the app in Play Console and fill in the store listing: name, short and full description, screenshots, and an icon.
3. Complete the forms: privacy policy (required if you handle user data), data safety, content rating and target audience.
4. Upload the AAB to Internal testing first, then to Closed or Open testing, and fix what testers find.
5. When ready, create a Production release and send it for review. Reviews can take days.
6. After release, read reviews and Android vitals, then ship updates with a higher versionCode.

Where to go next

• Architecture: read Google's guide to app architecture, then practise on your own apps.
• Kotlin Flow and coroutines in depth: testing, cancellation and error handling.
• Compose animation and custom layouts.
• Modules, CI/CD and Gradle convention plugins for larger teams.
• Kotlin Multiplatform, to share logic with iOS.

Interview preparation

Interviewers want to know that you understand the basics and can explain your choices. Practise answering these aloud, using your own projects as examples.

• What is the difference between val and var, and a data class and a normal class?
• How does Kotlin help avoid null pointer errors?
• What is a composable function, and what is recomposition?
• Explain remember, rememberSaveable and state hoisting.
• What is a ViewModel, and why does it survive rotation?
• What is a coroutine? What is the difference between launch and async?
• What is Flow, and how is it different from a List?
• How would you store data on the device? When do you choose DataStore over Room?
• What problem does dependency injection solve?
• How do you handle errors from the network?
• How does the Activity lifecycle affect your app, and how does Compose reduce lifecycle problems?
• How do you test a ViewModel?

Build a short portfolio: publish two or three of these apps to GitHub with a clear README, screenshots and the steps to run them. If you can, put one app on the Play Store. Real, working projects with honest descriptions are worth more than a long list of keywords.

Your task

1. Choose your best project and set its application ID, version and icon.
2. Build a signed release AAB and install it on a phone.
3. Write a README with a screenshot, the features and the libraries used.
4. Answer five of the interview questions aloud and write down any that you could not answer.

How to check it worked

• The release build runs without crashes on a real device.
• The keystore and passwords are stored safely and not in your repository.
• You can describe the path from code to Play Store in order.