Welcome! In this journey, we'll walk through the complete process of building a React Native application from scratch. We'll start by setting up the development environment, creating a development build, and testing it on a local system or mobile device. Then, we'll generate a production-ready build for Android and test it thoroughly. Finally, we'll take the last step — deploying the app to the Google Play Store. Let's get started! 🚀

Creating a React Native App

When starting a React Native project, we have two main approaches:

1. Using Expo — Recommended for beginners as it simplifies setup and development. We'll discuss about expo later in this blog.
2. Using React Native CLI — Offers more customization but requires additional configuration.

For this guide, we'll use Expo to create our app, as it provides a smoother development experience.

Step 1: Install Expo CLI

If you haven't installed Expo globally yet, run the following command:

npm install -g expo-cli

Step 2: Create a New Expo Project

Now, let's create our project. Replace MyApp with your desired project name from following command.

npx create-expo-app MyApp

Select "yes" to proceed.

Once the setup is complete, navigate to the project folder and start your development journey! 🚀

If you encounter an error during the npm install process, don't worry! We'll resolve it shortly by installing dependencies separately using either Yarn or npm after updating npm version.

Now, let's install the dependencies using Yarn. Simply run the following command:

yarn install
// or 
yarn

Checking Real-Time Changes in Your React Native App

When developing a React Native app, there are multiple ways to test changes in real time. However, Expo makes this process incredibly simple and efficient and made our life happy.

What is Expo and Why is it Helpful?

Expo is an open-source framework that simplifies React Native development by providing a set of tools and services. It eliminates the need for complex native configurations, making it ideal for both beginners and experienced developers. With Expo, you can:

✅ Quickly set up and run your app without worrying about native dependencies. ✅ Use the Expo Go app to preview changes on your mobile device in real time. ✅ Seamlessly create both development and deployment builds with EAS (Expo Application Services). ✅ Test your app on a physical device, simulator, or even in a web browser.

Ways to Test Your App in Real Time

1. Running Locally — You can start the development server and preview your app in a web browser. With dev tools, you can inspect and switch to a mobile screen layout.
2. Using the Expo Go App — Install the Expo Go app from the Play Store or App Store. Start your project and either scan the provided QR code or open the link directly to load your app instantly.
3. Testing on a Simulator/Emulator — You can run your app on an Android Emulator or iOS Simulator to test different screen sizes and device behaviors.

💡 Don't worry! We'll explore each of these methods step by step in this guide. 🚀

Running and Testing locally on browser

Now navigate to your project directory and run the following command to start your app:

npx expo start
// or
npm start

Next, open your browser and visit the web link provided in the terminal (as shown in the image above).

Open the browser's Developer Tools, inspect the tab, and switch to the mobile view.

Congratulations! 🎉 Your app is now running on your laptop browser and will reflect changes in real-time as you update your code.

Now before discussing about other ways first we should learn about how to create development builds using EAS.

Creating a development build (apk file) using EAS

Now, we will create a development build using EAS (Expo Application Services), which allows us to test our app on a real device in real time. Follow these steps:

Step 1: Install EAS CLI Globally

You can install EAS CLI using either Yarn or npm:

yarn global add eas-cli

or

npm install -g eas-cli

Step 2: Verify EAS Installation

Once installed, check the EAS version to confirm the installation:

eas --version

This ensures that EAS is correctly installed and ready to use. 🚀

Step 3: Create and Login to your EXPO Account

To use EAS (Expo Application Services) for building and deploying your app, you need an Expo account.

1. Create an Expo Account — If you don't already have one, sign up at Expo's official website.
2. Log in to Expo via CLI — Run the following command and enter your username/email and password when prompted:

eas login

Once logged in, you'll be able to use EAS to create and manage builds for your app. 🚀

Step 4: Creating a Development Build

To generate a development build for the Android platform, navigate to your project and run the following command:

eas build --profile development --platform android

Since this is your first build, EAS will prompt you to install expo-dev-client.

✅ Type "yes" and press Enter to proceed with the installation.

This package is essential for running development builds efficiently. 🚀

Now, EAS will prompt you to automatically create an EAS project with a default name as shown in image below.

✅ You can either accept the default name or enter a custom project name. ✅ Once done, choose "Yes" to proceed.

This will set up your project for future EAS builds seamlessly. 🚀

During the build process, the prompt will ask you to create an Android Application ID with a default value as shown in image above.

✅ You can either accept the default ID or enter a custom one. ✅ Press "Enter" to proceed.

This ID is essential for identifying your app on the Google Play Store. 🚀

Now, again during the build process, EAS will prompt you to generate a new Android Keystore as shown in the image below.

✅ Type "yes" and press Enter to allow EAS to create one for you.

This Keystore is required for signing your app before publishing it to the Google Play Store. 🚀

✅ Your build is now in queue and will start shortly. 🚀 You can monitor the progress in the terminal or on the Expo Dashboard.

🚀 Congrats! Your build is in progress, wait for its completion.

Once completed, you'll receive a download link for your APK file as show below in image, ready for testing! 🎉

After the process, you will be prompted to install and run the Android build on an emulator.

✅ Type "No" and press Enter to skip this step for now. 📌 We will cover this in detail later in the blog.

Your build will continue as expected! 🚀

🎉 Well done! You have successfully created a development build for your project. Now, you can install the APK on your Android device and test your changes in real-time. 🚀

Running Using Expo Go App

Go to the Play Store and install the Expo Go app on your mobile device.

1. Install the Development Build — Transfer the APK file (generated in the last step) to your Android device and install it.
2. Open Your App — Once installed, launch the app on your mobile device.
3. Restart Your Project — Now, restart your development server by running:

npx expo start

or

npm start

Now, you can launch your app by doing one of the following:

✅ Scan the QR Code — Use your phone's camera to scan the QR code provided in the terminal. ✅ Manually Enter the Link — Open the Expo Go app and enter the link displayed below the QR code (e.g., exp://192.168.29.116:8081). ✅ Use the Development Build – Open the development app you installed and enter the same link.

🎉 Your app is now running on your Android device, and you can test changes in real-time! 🚀

⚠️ Note: If you install any new dependencies, you'll need to restart the app for the changes to take effect.

Testing on Simulator or Emulator

Before creating a development build, we will install Android Studio as we want to test our build on an Android Emulator instead of a physical device.

👉 Download and install Android Studio from the official website: Android Studio Download.

Now create development build by running following command:

eas build --profile development --platform android

🎉 Great job! You've successfully started the development build process. Once the build process is complete, the terminal will prompt you with an option to install the build on Android Studio as shown in image below.

✅ Click "Yes" to download and install the development build on your Android emulator as shown in image below. This will download your development build to your simulation.

This will allow you to test your app directly on the Android Studio virtual device. 🚀

Now, restart your Expo development server by running the following command:

npx expo start

This will ensure your app is running and ready for real-time testing. 🚀

To open your development build in the Android emulator, type a in the terminal as it is shown in the image above.

a

(This option is shown in the terminal output.)

🎉 Your app will now launch in the emulator, and you can test changes in real-time! 🚀

Next Step: Preparing for Deployment 🚀

🎉 Congratulations! You have successfully created your React Native app, developed features, and tested it both locally and with a development build. Now, it's time to take the next big step — creating a deployment build and publishing it on the Google Play Store or Expo.

Stay tuned as we guide you through the deployment process! 🚀✨

Deploying on Google Play Store (Without Expo)

As we're using React Native CLI, we will follow these steps to generate a release APK for Android.

1. Navigate to the Android Folder

Make sure you're in your React Native project directory, then move into the android folder:

cd android

2. Generate a Keystore File

A keystore is required to sign the APK before publishing. You can generate one using the following command:

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

• It will prompt you for information:
• Keystore password → Remember this, as you'll need it later.
• First and last name (Enter your name or app-related name)
• Organizational unit (Optional)
• Organization name (Optional)
• City/locality (Enter your city)
• State/province (Enter your state)
• Country code (Two-letter country code, e.g., US for the USA)
• After running this command, a file named my-release-key.jks will be created in your current directory.

Move Keystore to Your Project

Move the keystore file to android/app/ by running:

mv my-release-key.jks ../app/

3. Configure Keystore in gradle.properties

Open the file android/gradle.properties and add the following lines:

MYAPP_UPLOAD_STORE_FILE=my-release-key.jks
MYAPP_UPLOAD_KEY_ALIAS=my-key-alias
MYAPP_UPLOAD_STORE_PASSWORD=your-keystore-password
MYAPP_UPLOAD_KEY_PASSWORD=your-key-password

Replace your-keystore-password and your-key-password with the ones you set during keystore creation.

4. Update android/app/build.gradle

Edit android/app/build.gradle and find the signingConfigs section. Modify it like this:

android {
    ...
    signingConfigs {
        release {
            storeFile file(MYAPP_UPLOAD_STORE_FILE)
            storePassword MYAPP_UPLOAD_STORE_PASSWORD
            keyAlias MYAPP_UPLOAD_KEY_ALIAS
            keyPassword MYAPP_UPLOAD_KEY_PASSWORD
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
            minifyEnabled true // Enables code shrinking
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

5. Generate the APK

Now, run the following command from the android/ directory:

./gradlew assembleRelease

If you get a permission denied error, try:

chmod +x gradlew
./gradlew assembleRelease

6. Locate the APK

Once the build completes, your release APK will be located at:

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

You can now transfer this APK to your phone for testing or upload it to the Play Store.

7. Generate an AAB (Recommended for Play Store)

Google Play now prefers AAB (Android App Bundle) instead of APK. To generate an AAB, run:

./gradlew bundleRelease

The AAB file will be located at:

android/app/build/outputs/bundle/release/app-release.aab

Next Steps

1. Test the APK on a device — Copy the .apk file to your phone and install it.
2. Upload AAB to Play Console — Use Google Play Console to submit your app.

Deployment on Google Play Story using Expo

Before publishing, we need to generate a production-ready deployment build. Run the following command from your project directory:

eas build -p android --profile production

This will create a production build that can be uploaded to the Google Play Store or published on Expo. 🚀

Once the build is complete, we'll move on to publishing it! 🎉

Lets follow these steps to deploy it.

1. Initialize EAS in Your Project

Navigate to your project folder:

cd MyApp
eas init

This will create an eas.json file where you can configure your builds.

2. Configure Your eas.json File

Edit the eas.json file in your project root to define a production build profile.

{
  "build": {
    "production": {
      "distribution": "store",
      "android": {
        "buildType": "app-bundle"
      },
      "ios": {
        "simulator": false
      }
    }
  }
}

• "app-bundle" → Required for Play Store submission.
• "store" → Ensures the build is signed for distribution.

3. Set Up App Store & Play Store Credentials

For Android

Expo can manage credentials automatically. If you want to provide your own Keystore, run:

eas credentials

Or, let Expo generate one during the build.

4. Build the Production Version

Run the following command to start the build:

eas build -p android --profile production

• This will generate an Android App Bundle (AAB) file.
• The build process runs on Expo servers, so wait for the completion link.

5. Download the Build

Once the build is complete, Expo will give you a download link. Copy the URL and download the .aab file.

6. Upload AAB to Google Play Store

1. Go to Google Play Console (play.google.com/console)
2. Create a New App:

• Fill in app name, language, and other details.
• Select "App" and choose your category.

3. Upload the AAB:

• Navigate to Production → Create a new release.
• Upload the AAB file downloaded from Expo.

4. Complete the Store Listing:

• Add an app description, screenshots, and privacy policy.

5. Submit for Review:

• Click "Submit for Review" and wait for Google to approve your app.

7. Deploy Updates Using eas update

Once your app is live, you can push updates without needing a new Play Store submission.

To update your production build:

eas update --branch production

• This pushes updates to all users without requiring a full build.
• Make sure you test thoroughly before updating production.

🎉 Done! Your Expo app is now live on Google Play Store!

🎉 Congratulations! You have successfully set up, built, and launched your React Native app for real-time testing. Now, you can develop with confidence, knowing your changes reflect instantly on your device or emulator. 🚀 Happy coding! 😊