LunadeckLunadeck

Vibe code to app stores

Android on Windows

11 min read

A step-by-step guide for shipping a vibe-coded Flutter app to Google Play from a Windows machine — covering Flutter SDK installation, signing, and the full Play Store submission process.

If you're using Lunadeck, the build and signing steps (Parts 3–5) 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 10 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 Flutter 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: Flutter SDK, Java (JDK 17), and Android Studio.

1.1 Install Git for Windows

Flutter requires Git. Download and install it from https://git-scm.com/download/win. Accept all defaults.

Verify in a new terminal:

git --version

1.2 Install the Flutter SDK

Step 1: Download Flutter

Go to https://docs.flutter.dev/get-started/install/windows/mobile and download the latest stable Flutter SDK .zip for Windows.

Step 2: Extract

Extract the .zip to a folder without spaces in the path — for example C:\flutter or C:\dev\flutter. Do not install to C:\Program Files — the spaces cause issues with some tools.

# Example using PowerShell (or just use File Explorer > Extract All)
Expand-Archive -Path "$env:USERPROFILE\Downloads\flutter_windows_*.zip" -DestinationPath "C:\flutter"

Step 3: Add Flutter to your PATH

  1. Press Win + S, search for "Environment Variables", click "Edit the system environment variables"
  2. Click "Environment Variables"
  3. Under User variables, find Path, click Edit > New, and add: C:\flutter\bin
  4. Click OK on everything

Close and reopen your terminal, then verify:

flutter --version

Step 4: Run flutter doctor

flutter doctor

flutter doctor lists everything Flutter needs and shows what's missing. Resolve any issues it reports before continuing.

1.3 Install Java (JDK 17)

  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:

java -version

If java is not recognized, set JAVA_HOME manually:

  1. Press Win + S > "Environment Variables"
  2. Under System variables, click New:
    • Variable name: JAVA_HOME
    • Variable value: C:\Program Files\Eclipse Adoptium\jdk-17.x.x-hotspot
  3. Find Path, click Edit > New, add: %JAVA_HOME%\bin
  4. Restart your terminal

1.4 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:

  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

Step 4: Set environment variables

By default, Android Studio installs the SDK to:

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

AppData is hidden. To see it: View > Show > Hidden items in File Explorer.

  1. Press Win + S > "Environment Variables"
  2. Under System variables, add:
    • ANDROID_HOME = C:\Users\YOUR_USERNAME\AppData\Local\Android\Sdk
    • ANDROID_SDK_ROOT = C:\Users\YOUR_USERNAME\AppData\Local\Android\Sdk
  3. Find Path under System variables, click Edit, and add:
    • %ANDROID_HOME%\platform-tools
    • %ANDROID_HOME%\cmdline-tools\latest\bin
  4. Click OK and restart your terminal

Verify:

adb --version

Step 5: Accept Android licenses

flutter doctor --android-licenses

Type y at each prompt.

1.5 Configure Flutter to use Android Studio

flutter config --android-studio-dir "C:\Program Files\Android\Android Studio"
flutter doctor

All Android checks in flutter doctor should now show a green checkmark.

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
tar -xf "$env: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 Verify the project structure

A valid Flutter project looks like:

my-app\
  android\
  lib\
    main.dart
  pubspec.yaml

2.3 Get dependencies

cd C:\Users\YOUR_USERNAME\my-app
flutter pub get

Common issues:

  • Pub resolution failure — a package version conflict. Read the error — it names the conflicting packages. Try flutter pub upgrade or adjust version constraints in pubspec.yaml.
  • Missing Flutter SDK version — run flutter upgrade to update to the latest stable.

2.4 Check your app configuration

Open pubspec.yaml and confirm the version field:

version: 1.0.0+1   # versionName+versionCode

Open android\app\build.gradle and check the applicationId:

defaultConfig {
    applicationId "com.yourname.myapp"
    ...
}

applicationId is permanent. If it says com.example.myapp, change it now before your first Play Store upload.

Part 3: Test Your App

3.1 Run on an emulator

In Android Studio > Device Manager, create a virtual device (Pixel 7, API 34+). Start it, then:

flutter run

Emulator performance on Windows: Enable hardware virtualization in BIOS/UEFI (Intel VT-x or AMD-V), then enable Windows Hypervisor Platform in Windows Features (Settings > Apps > Optional features > More Windows features).

3.2 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. Verify Flutter sees the device:
flutter devices

Then:

flutter run

3.3 Common issues

"No devices found" — check flutter devices. Make sure the emulator is fully booted. For a physical device, verify USB Debugging is on and you've accepted the debug prompt on the device.

Build fails with Gradle errors — try flutter clean before rebuilding. Read the full Gradle error output — it usually names the problem precisely.

Plugin errors — a Flutter plugin may require a minimum Android SDK version. Update minSdkVersion in android\app\build.gradle if needed.

Part 4: Prepare for Release

4.1 Set your app icon

Add the flutter_launcher_icons package to pubspec.yaml:

dev_dependencies:
  flutter_launcher_icons: ^0.14.0
 
flutter_launcher_icons:
  android: true
  ios: false
  image_path: "assets/icon.png"
  adaptive_icon_background: "#FFFFFF"
  adaptive_icon_foreground: "assets/icon-foreground.png"

Place your icon (at least 1024×1024 px) at assets\icon.png, then:

flutter pub get
dart run flutter_launcher_icons

4.2 Set your splash screen

dev_dependencies:
  flutter_native_splash: ^2.4.0
 
flutter_native_splash:
  color: "#FFFFFF"
  image: assets/splash.png
  android: true
  ios: false
flutter pub get
dart run flutter_native_splash:create

4.3 Update your app version

In pubspec.yaml:

version: 1.0.0+1
#         ^^^^^  versionName shown to users
#               ^ versionCode — must increment with each Play Store upload

4.4 Configure app permissions

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

<!-- Internet access — required for most apps -->
<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" /> -->

Part 5: Sign and Build the Release Bundle

5.1 Generate a signing key

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 JAVA_HOME and PATH (see Part 1.3), or use the full path:

& "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.

5.2 Configure Flutter signing

Create android\key.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("key.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
        }
    }
}

5.3 Build the release bundle

cd C:\Users\YOUR_USERNAME\my-app
flutter build appbundle --release

Your signed .aab file will be at:

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

Part 6: 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
  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, and follow the verification steps.

Part 7: 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

7.1 Create your app listing

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

  • Store listing — description, at least 2 screenshots, 1024×500 feature graphic, 512×512 icon, category, contact details
  • Content rating — complete the IARC questionnaire honestly
  • Target audience — do not select children unless your app specifically targets them
  • Privacy policy — required if your app collects any user data

7.2 Set up closed testing and upload your build

  1. Go to Testing > Closed testing in the left sidebar
  2. Create a tester email list with at least 12 Gmail addresses
  3. Click Create new release, accept Play App Signing, upload your .aab
  4. Add release notes and click Start rollout
  5. Share the generated opt-in link with your testers — they must install the app on a real Android device

After 14 days with all testers opted in, apply for production access from the app Dashboard.

Part 8: Publish to Production

Once you have production access:

  1. Production > Create new release
  2. Upload your .aab, add release notes, select distribution countries
  3. Click Start rollout to production

Part 9: Updating Your App

# 1. Make your code changes
 
# 2. Increment the build number in pubspec.yaml
#    e.g., 1.0.0+1 → 1.0.0+2
 
# 3. Rebuild
flutter build appbundle --release
 
# 4. Upload the new .aab in Google Play Console

Quick Reference

# === SETUP ===
flutter pub get
flutter doctor --android-licenses
 
# === TESTING ===
flutter devices
flutter run
 
# === RELEASE BUILD ===
flutter build appbundle --release
# Output: build\app\outputs\bundle\release\app-release.aab
 
# === CLEAN BUILD ===
flutter clean
flutter pub get
flutter build appbundle --release

Troubleshooting

"flutter is not recognized" — Flutter's bin folder is not in your PATH. Follow Part 1.2 Step 3 and restart your terminal.

"Android licenses not accepted" — run flutter doctor --android-licenses and type y at each prompt.

"JAVA_HOME is not set" — set it as a system environment variable pointing to your JDK directory, and add %JAVA_HOME%\bin to Path.

keytool not recognized — Java's bin folder is not in your PATH. Use the full path to keytool.exe or fix your JAVA_HOME / Path settings.

Long path errors — 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.

Gradle build fails — run flutter clean then rebuild. Check the full error output — Gradle errors name the problem precisely.

App crashes at launch — run flutter run in debug mode and read the stack trace.

Emulator is extremely slow — enable hardware virtualization in BIOS/UEFI and enable Windows Hypervisor Platform in Windows Features.

Realistic Expectations

The timeline is longer than you expect. The 14-day testing requirement plus review means 3–4 weeks from start to live.

AI-generated Flutter code frequently has plugin issues. Flutter plugins often require minimum SDK versions or extra setup steps. Budget time for resolving them.

Google can reject your app. Common reasons: missing privacy policy, misleading store listing, or the app crashing during review.

Finding 12 testers is harder than it sounds. Start recruiting early. Developer communities on Discord and Reddit (r/flutterdev, r/androiddev, r/betatesting) organize tester exchanges.