LunadeckLunadeck

Vibe code to app stores

Android on Windows

14 min read

A step-by-step guide for shipping a vibe-coded React Native or Expo app to Google Play from a Windows machine — covering tool installation, prebuild, signing, and the full Play Store submission process.

If you're using Lunadeck, the build and signing steps (Parts 4–6) are handled for you automatically. This guide is for building and publishing locally, or for understanding what Lunadeck does under the hood.

What you'll need before starting:

  • A Windows 10 or Windows 11 computer (64-bit)
  • At least 12 GB of free disk space
  • At least 8 GB of RAM (16 GB recommended — the Android emulator is a memory hog)
  • A credit/debit card ($25 one-time Google Play fee)
  • Your exported React Native / Expo project (ZIP from your AI coding tool, or a git clone)
  • About 2–4 hours for initial setup, then ~3 weeks for the publishing process

Part 1: Install the Required Tools

You need three things: Node.js, Java (JDK 17), and Android Studio.

1.1 Install Node.js (v18+)

Option A: Using nvm-windows (recommended)

nvm-windows lets you switch between Node.js versions. It's a separate project from the Linux/Mac nvm, same concept, different tool.

  1. If you already have Node.js installed, uninstall it first via Settings > Apps. nvm-windows conflicts with existing installations.
  2. Go to the nvm-windows releases page and download nvm-setup.exe from the latest release.
  3. Run the installer. Accept the default installation directory and avoid paths with spaces.
  4. Close and reopen your terminal after installation.

Then install Node.js 22 from an Administrator terminal (right-click PowerShell > "Run as administrator"):

nvm install 22
nvm use 22
 
# Verify
node --version   # Should show v22.x.x
npm --version

Option B: Direct installer from nodejs.org

Go to https://nodejs.org and download the Windows installer (.msi) for Node.js 22.x. Run it and accept all defaults.

node --version

1.2 Install Java (JDK 17)

Android Studio bundles its own JDK, but having one system-wide prevents keytool from being missing when you need to sign your app.

  1. Go to https://adoptium.net/ (Eclipse Temurin) and download the JDK 17 Windows .msi installer.
  2. Run the installer. When prompted about custom setup, make sure "Set JAVA_HOME variable" is checked.
  3. Accept the defaults and finish.

Verify in a new terminal window:

java -version

If java is not recognized after installation, set JAVA_HOME manually:

  1. Press Win + S, search for "Environment Variables", and click "Edit the system environment variables"
  2. Click "Environment Variables" at the bottom
  3. Under System variables, click New:
    • Variable name: JAVA_HOME
    • Variable value: C:\Program Files\Eclipse Adoptium\jdk-17.x.x-hotspot (adjust to your actual path)
  4. Find the Path variable, click Edit, and add a new entry: %JAVA_HOME%\bin
  5. Click OK on everything and restart your terminal

1.3 Install Android Studio

Step 1: Download and install

Go to https://developer.android.com/studio and download the Windows .exe installer. Run it:

  1. Accept the license agreement
  2. Keep both "Android Studio" and "Android Virtual Device" checked
  3. Accept the default installation directory
  4. Click Install and wait

Step 2: First-time setup wizard

When Android Studio launches for the first time:

  1. Choose "Do not import settings"
  2. Select "Standard" installation type
  3. Let it download the Android SDK, build tools, and emulator

Step 3: Install SDK components

Go to Tools > SDK Manager:

  • SDK Platforms tab: check Android 14 (API 34) or newer
  • SDK Tools tab: check Android SDK Build-Tools, Android SDK Command-line Tools, Android Emulator, Android SDK Platform-Tools

Click Apply and let it download.

Step 4: Set environment variables

By default, Android Studio installs the SDK to:

C:\Users\YOUR_USERNAME\AppData\Local\Android\Sdk

The AppData folder is hidden by default. To see it in File Explorer, click View > Show > Hidden items (Windows 11) or View > Hidden items (Windows 10).

  1. Press Win + S, search for "Environment Variables", and click "Edit the system environment variables"
  2. Click "Environment Variables"
  3. Under System variables, click New and add:
    • ANDROID_HOME = C:\Users\YOUR_USERNAME\AppData\Local\Android\Sdk
    • ANDROID_SDK_ROOT = C:\Users\YOUR_USERNAME\AppData\Local\Android\Sdk
  4. Find Path under System variables, click Edit, and add:
    • %ANDROID_HOME%\platform-tools
    • %ANDROID_HOME%\tools
    • %ANDROID_HOME%\tools\bin
    • %ANDROID_HOME%\cmdline-tools\latest\bin
  5. Click OK on everything

Restart your terminal and verify:

adb --version

Part 2: Export and Prepare Your Project

2.1 Get your project files

If your AI tool provides a ZIP export, download and unzip it:

mkdir C:\Users\YOUR_USERNAME\my-app
cd C:\Users\YOUR_USERNAME\my-app
 
# Windows 10 1803+ has tar built in:
tar -xf %USERPROFILE%\Downloads\your-project.zip -C .

Or right-click the .zip in File Explorer and select "Extract All...".

If you're working from a git repository:

git clone https://github.com/yourname/your-app.git %USERPROFILE%\my-app
cd %USERPROFILE%\my-app

2.2 Install dependencies

cd C:\Users\YOUR_USERNAME\my-app
npm install

Common issues with AI-generated exports:

  • Missing .env variables — create a .env file with any required API keys
  • Dependency conflicts — delete node_modules and package-lock.json, then re-run npm install
  • TypeScript errors — fix the specific file and line number the error points to

2.3 Confirm your project type

Open package.json and look at "dependencies":

  • Contains "expo" → Expo managed workflow — follow Part 3A
  • Contains "react-native" but not "expo" → Bare React Native — follow Part 3B

Part 3A: Expo Managed Workflow

Skip to Part 3B if your project is bare React Native.

3A.1 Check your app.json

Open app.json and verify the "expo" section contains at minimum:

{
  "expo": {
    "name": "My App",
    "slug": "my-app",
    "android": {
      "package": "com.yourname.myapp"
    }
  }
}

The android.package value is permanent. Once you publish to Google Play, you cannot change it. Use a reverse-domain format: com.yourname.appname.

If android.package is missing, add it now.

3A.2 Run prebuild

Expo prebuild reads your app.json and generates the native android\ project:

npx expo prebuild --platform android

This creates the android\ directory. You only need to run this again if you change app.json, add or remove native packages, or want to regenerate the native project from scratch.

If android\ already exists, prebuild will ask if you want to overwrite it. Answer yes unless you've made manual changes to the native project — manual changes are not preserved through prebuild.

3A.3 Verify the generated project

After prebuild completes:

dir android\
# Should contain: app\, build.gradle, gradlew.bat, settings.gradle, etc.

Part 3B: Bare React Native

Skip this if your project is Expo-managed.

3B.1 Verify the android directory

Your project should already have an android\ directory committed to it. Verify:

dir android\
# Should contain: app\, build.gradle, gradlew.bat, settings.gradle, etc.

If there is no android\ directory, your project may actually be Expo — check whether "expo" is in your package.json dependencies and follow Part 3A instead.

3B.2 Install native dependencies

cd C:\Users\YOUR_USERNAME\my-app
npm install

For React Native 0.60+, autolinking handles most packages automatically. If any package requires manual linking, its documentation will say so.

Part 4: Test Your App

4.1 Start Metro and run on Android

Open two separate PowerShell windows:

Window 1 — Metro bundler:

cd C:\Users\YOUR_USERNAME\my-app
npx react-native start

Window 2 — launch on device/emulator:

cd C:\Users\YOUR_USERNAME\my-app
npx react-native run-android

4.2 Run on an emulator

In Android Studio:

  1. Open Device Manager (phone icon with wrench)
  2. Click Create Virtual Device, pick a Pixel device, and download a system image (API 34+)
  3. Select the emulator from the device dropdown and click Run (▶)

Emulator performance on Windows: The Android emulator uses hardware acceleration via Intel HAXM or Windows Hypervisor Platform (WHPX). If it's extremely slow, make sure hardware virtualization is enabled in your BIOS/UEFI (usually "Intel VT-x" or "AMD-V"). Enable Windows Hypervisor Platform in Windows Features: Settings > Apps > Optional features > More Windows features.

4.3 Run on a physical device

  1. Enable Developer Options: Settings > About Phone > tap "Build Number" 7 times
  2. Enable USB Debugging: Settings > Developer Options > USB Debugging
  3. Connect via USB and accept the debugging prompt
  4. Select your device in Android Studio and click Run, or run npx react-native run-android

4.4 Common issues

Metro bundler not starting — make sure it's running in a separate terminal window with npx react-native start.

"SDK location not found" — ANDROID_HOME is not set. Follow Part 1.3 Step 4 and restart your terminal. You can also create android\local.properties with:

sdk.dir=C:\\Users\\YOUR_USERNAME\\AppData\\Local\\Android\\Sdk

App crashes immediately — check Logcat in Android Studio (View > Tool Windows > Logcat).

Red error screen in the app — a JavaScript error. Read the message — it usually points directly to the file and line.

"Duplicate resources" — clean the build: cd android && .\gradlew.bat clean

Part 5: Prepare for Release

5.1 Set your app icon

Expo projects: add your icon path to app.json and re-run prebuild:

{
  "expo": {
    "icon": "./assets/icon.png",
    "android": {
      "adaptiveIcon": {
        "foregroundImage": "./assets/adaptive-icon.png",
        "backgroundColor": "#FFFFFF"
      }
    }
  }
}

The icon image must be at least 1024×1024 px. After updating app.json:

npx expo prebuild --platform android

Bare React Native: use Android Studio's File > New > Image Asset wizard to generate icon sizes from a single 1024×1024 px source.

5.2 Set your splash screen

Expo projects: set in app.json:

{
  "expo": {
    "splash": {
      "image": "./assets/splash.png",
      "resizeMode": "contain",
      "backgroundColor": "#FFFFFF"
    }
  }
}

Then re-run npx expo prebuild --platform android.

5.3 Update your app version

In android\app\build.gradle:

versionCode 1       // Integer, must increase with every Play Store upload
versionName "1.0"   // Human-readable string shown to users

For Expo projects, you can also set these in app.json:

{
  "expo": {
    "version": "1.0.0",
    "android": {
      "versionCode": 1
    }
  }
}

5.4 Configure app permissions

In android\app\src\main\AndroidManifest.xml, inside the <manifest> tag:

<!-- Internet access — required for most apps, verify it's present -->
<uses-permission android:name="android.permission.INTERNET" />
 
<!-- Add only what your app actually uses: -->
<!-- <uses-permission android:name="android.permission.CAMERA" /> -->
<!-- <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> -->
<!-- <uses-permission android:name="android.permission.RECORD_AUDIO" /> -->

Part 6: Sign and Build the Release Bundle

6.1 Generate a signing key

Open Command Prompt or PowerShell and run:

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

If keytool is not recognized: Java's bin directory isn't in your PATH. Fix your JAVA_HOME and PATH (see Part 1.2), or use the full path. In PowerShell:

& "C:\Program Files\Eclipse Adoptium\jdk-17.0.x-hotspot\bin\keytool.exe" -genkey -v -keystore %USERPROFILE%\my-app-release.keystore -alias my-app-key -keyalg RSA -keysize 2048 -validity 10000

Back up this keystore file and both passwords. Losing it means you can never update your app on Google Play. Store a copy in a password manager and on external storage.

6.2 Configure Gradle signing

Create android\keystore.properties (do NOT commit this to git — add it to .gitignore):

storeFile=C:\\Users\\YOUR_USERNAME\\my-app-release.keystore
storePassword=your_keystore_password
keyAlias=my-app-key
keyPassword=your_key_password

Windows path note: Use double backslashes (\\) or forward slashes (/). A single backslash is an escape character in .properties files.

Edit android\app\build.gradle — add above the android { block:

def keystorePropertiesFile = rootProject.file("keystore.properties")
def keystoreProperties = new Properties()
if (keystorePropertiesFile.exists()) {
    keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
}

Inside the android { block:

android {
    // ... existing config ...
 
    signingConfigs {
        release {
            storeFile file(keystoreProperties['storeFile'])
            storePassword keystoreProperties['storePassword']
            keyAlias keystoreProperties['keyAlias']
            keyPassword keystoreProperties['keyPassword']
        }
    }
 
    buildTypes {
        release {
            signingConfig signingConfigs.release
            minifyEnabled true
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

6.3 Build the release bundle

cd C:\Users\YOUR_USERNAME\my-app\android
.\gradlew.bat bundleRelease

Windows difference: On Linux/macOS the command is ./gradlew bundleRelease. On Windows it's .\gradlew.bat bundleRelease. In Command Prompt (no .\ needed): gradlew bundleRelease.

Your signed .aab file will be at:

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

If the build fails — read the error output carefully. Common causes: missing SDK components (fix in SDK Manager), Gradle version mismatch (don't upgrade when prompted), or Java version issues (confirm JDK 17 is installed and JAVA_HOME points to it).

Part 7: Create a Google Play Developer Account

  1. Go to https://play.google.com/console
  2. Sign in with your Google account
  3. Choose Personal or Organization account (Personal is fine for indie developers)
  4. Pay the one-time $25 USD registration fee
  5. Complete identity verification
  6. Wait 24–48 hours for activation

Personal accounts created after November 2023 require a device verification step. Install the Google Play Console mobile app on an Android device, sign in with the same Google account, and follow the verification steps.

Part 8: The Closed Testing Requirement

New personal developer accounts cannot publish directly to production. Google requires:

  1. Uploading your app to a closed test track
  2. Having at least 12 testers opted in
  3. Those testers must remain opted in for 14 consecutive days
  4. Only then can you apply for production access

8.1 Create your app listing

In Google Play Console, click Create app and work through all required sections:

  • Store listing — app description, at least 2 phone screenshots, 1024×500 feature graphic, 512×512 icon, category, contact details
  • Content rating — complete the IARC questionnaire honestly
  • Target audience — if not specifically for children, do not select children as target
  • Privacy policy — required if your app collects any user data; a simple page on GitHub Pages or Notion works

8.2 Set up closed testing and upload your build

  1. Go to Testing > Closed testing in the left sidebar
  2. Under Testers, create a list with at least 12 Gmail addresses
  3. Click Create new release, accept Play App Signing, and upload your .aab file
  4. Add release notes and click Start rollout
  5. Share the generated opt-in link with your testers

Testers must click the link on an Android device, accept the invitation, and install the app. After 14 days with all testers opted in, you can apply for production access from the app Dashboard.

Part 9: Publish to Production

Once you have production access:

  1. Go to Production > Create new release
  2. Upload your .aab file
  3. Add release notes and select distribution countries
  4. Click Start rollout to production

First-submission review typically takes a few hours to several days. If approved, your app goes live.

Part 10: Updating Your App

Expo projects:

# 1. Make your code changes
 
# 2. If you changed app.json or added/removed native packages:
npx expo prebuild --platform android
 
# 3. Bump versionCode in android\app\build.gradle
 
# 4. Build the new bundle
cd android
.\gradlew.bat bundleRelease
 
# 5. Upload the new .aab in Google Play Console

Bare React Native:

# 1. Make your code changes
 
# 2. Bump versionCode in android\app\build.gradle
 
# 3. Build the new bundle
cd android
.\gradlew.bat bundleRelease
 
# 4. Upload the new .aab in Google Play Console

Quick Reference

# === EXPO: ONE-TIME SETUP ===
npm install
npx expo prebuild --platform android
 
# === TESTING ===
npx react-native start          # Terminal 1
npx react-native run-android    # Terminal 2
 
# === RELEASE BUNDLE ===
cd android
.\gradlew.bat bundleRelease
# Output: android\app\build\outputs\bundle\release\app-release.aab

Troubleshooting

"SDK location not found" — ANDROID_HOME is not set. Follow Part 1.3 Step 4, restart your terminal, or create android\local.properties with sdk.dir=C:\\Users\\YOUR_USERNAME\\AppData\\Local\\Android\\Sdk.

"JAVA_HOME is not set" or "java is not recognized" — Add JAVA_HOME as a system environment variable pointing to your JDK (e.g., C:\Program Files\Eclipse Adoptium\jdk-17.0.x-hotspot) and add %JAVA_HOME%\bin to Path.

Gradle fails with "Could not determine java version" — multiple Java versions installed. Make sure JAVA_HOME points specifically to JDK 17.

.\gradlew.bat not recognized — make sure you're in the android\ directory. In PowerShell use .\gradlew.bat; in Command Prompt just gradlew bundleRelease.

keytool not recognized — Java's bin folder is not in your PATH. Fix your PATH or use the full path to keytool.exe as shown in Part 6.1.

Long path errors — Android projects can exceed Windows' default 260-character path limit. Enable long paths in PowerShell (as Admin):

New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name "LongPathsEnabled" -Value 1 -PropertyType DWORD -Force

Then restart your computer.

Emulator is extremely slow — enable hardware virtualization in BIOS/UEFI (Intel VT-x or AMD-V), then enable Windows Hypervisor Platform in Windows Features.

npx expo prebuild fails — check for missing android.package in app.json, run npm install first, and check for dependency version conflicts.

App shows red error screen — a JavaScript error, not a build error. Read the message on screen — it names the file and line. Fix it and reload (r in the Metro terminal).

Realistic Expectations

The timeline is longer than you expect. Between the 14-day testing requirement, Google's review process, and debugging, plan for 3–4 weeks from start to live.

AI-generated React Native code often has issues the AI couldn't test. Red screens, missing permissions, and native module errors are common. Budget time for debugging — it's normal.

Google can reject your app. Common reasons: missing privacy policy, misleading store listing, or the app crashing during review. Read Google's developer policies before submitting.

Finding 12 testers is harder than it sounds. Start recruiting before you finish building. Developer communities on Discord and Reddit (r/reactnative, r/androiddev, r/betatesting) organize tester exchanges.