Skip to content
Winter Sale from $619, until 31st December 2026 Book now
From agentic coding tool to Google Play Android · Google Play Lovable

Lovable to Google Play: An Agentic Route from GitHub Sync to Production Access

Lovable has no Android export, but its GitHub sync gives a coding agent what it needs to build an Android shell around your published app: a Gradle project, a signed App Bundle and a CI pipeline that uploads to Play. Plan around Google's calendar – new personal accounts need a 14-day closed test with at least 12 testers – and keep Play Console, signing keys and policy forms with a person.

8 min read

Key takeaways

  • Google's timeline, not the code, sets the pace: start the developer account and the closed test planning before the agent writes the Android project.
  • Android builds run on Linux, so cloud agents and ordinary CI runners can build the App Bundle – unlike the iOS side.
  • Digital Asset Links must list the SHA-256 fingerprint of Google's app signing key, not your upload key – a mistake agents make easily.
  • The agent can draft the Data safety answers from the code it reads, but a person checks and submits them in Play Console.

The plan, week by week

On Android, the slow part of shipping a Lovable app is not the shell – a capable coding agent writes a working one in a day or two. The slow part is Play Console. Personal developer accounts created after November 13, 2023 must run a closed test with at least 12 testers who stay opted in for 14 consecutive days before they can even apply for production. So organise the work around that clock:

WhenYouThe agent
Week 0Register the Play developer account, complete identity checks, choose the package nameReads the Lovable repository and proposes an architecture and task list
Week 1Create the app in Play Console, accept Play App Signing, line up testersBuilds the shell and the CI pipeline, ships the first build to internal testing
Weeks 2–3Run the closed test, collect feedback, keep testers opted inTurns feedback into fixes and ships new builds to the closed track
Week 4Apply for production access, submit the policy formsDrafts release notes, the Data safety inventory and the reviewer instructions

Organization accounts are not bound by the closed-test rule, but they need a D-U-N-S number, which can take time of its own. Details are in our guide to the 12 testers and 14 days requirement.

Give the agent two repositories

Connect your Lovable project to GitHub. The sync is two-way, so treat that repository as Lovable's territory: you and Lovable edit it, and the agent only sends small pull requests on branches – an app-mode layout keyed to a user-agent marker, a delete-account flow, a public page for deletion requests, the assetlinks.json file. The Android project goes into a second repository the agent owns, with its own AGENTS.md or CLAUDE.md.

Here Android differs pleasantly from iOS: Gradle builds run on Linux. Codex cloud tasks, Cursor's background agents or the GitHub Copilot coding agent can build and test the shell in their cloud environments – as long as the environment can install the Android SDK and reach the Gradle repositories. Check that once before you rely on it; a cloud agent that cannot download dependencies will guess instead of compiling.

Talk to an AI Code Engineer about shipping your app to Google Play.

In a free call we look at what you built, tell you honestly what stands between it and an approved release – and whether you need us at all.

What the agent builds: a shell that behaves like an Android app

Projects created in Lovable since May 13, 2026 render on the server with TanStack Start, so the Android app loads your live custom domain. Two shells fit: a Trusted Web Activity, which needs a real PWA with a service worker you add to the Lovable app, or a WebView app in Kotlin, which gives the agent full control. Most teams choose the WebView app. Spell out these behaviours in the task list, because a bare WebView gets every one of them wrong:

  • Navigation scope. Your domain stays in the app; every other host opens in the browser.
  • Back gesture. Back steps through the web history and only leaves the app on the start screen. With target API level 36 the predictive back animation is on, so the agent must use the OnBackPressedDispatcher instead of overriding the old callback.
  • Edge-to-edge. Apps targeting recent API levels draw behind the system bars; the agent handles window insets so content stays tappable.
  • File uploads. A WebView ignores file inputs until the app implements onShowFileChooser.
  • Google sign-in. Google rejects OAuth requests from embedded WebViews, so the sign-in page opens in a Custom Tab and returns through a redirect the web app accepts.
  • Push. Firebase Cloud Messaging, with the notification permission requested at a meaningful moment rather than at first launch.
  • App Links. An assetlinks.json file on your primary domain, served without a redirect, so links to your site open the app.

Prefer a configured product to agent-written Kotlin? Our Lovable to Android guide compares the wrapper options, including the one our team makes.

Gradle, signing and the upload pipeline

Ask the agent for a Gradle setup that targets API level 36 – required for new apps and updates since August 31, 2026 – and increments versionCode automatically on every CI build, because Play refuses a version code it has seen before. The release build produces an Android App Bundle with ./gradlew bundleRelease.

Signing is split between you and Google. You create the upload key and keep it in a password manager with a backup; CI receives it as an encoded secret and the agent's Gradle config reads it from environment variables, never from the repository. Google holds the app signing key through Play App Signing and re-signs what users install.

That split causes the most common agent mistake on this route: putting the upload key's fingerprint into assetlinks.json. App Links and Google sign-in need the app signing key's SHA-256 fingerprint, which you copy from Play Console's app signing page. Give it to the agent as a fact in the instruction file.

For uploads, the agent can wire fastlane or the Gradle Play Publisher plugin to push each build to the internal track. The service account behind it is yours to create and authorise in Play Console. More on this in our GitHub Actions playbook for mobile CI.

Running the closed test with an agent in the loop

A closed test is not a formality you sit out. Google wants to see an app that was tested and improved. The agent makes that loop fast:

  1. Testers report problems in one place – a form, a shared board or GitHub issues.
  2. You turn each report into an issue with steps to reproduce and decide whether it is a web fix or a shell fix.
  3. Web fixes go through Lovable and a publish; shell fixes go to the agent as one issue per task.
  4. Every merged shell fix ends up as a new build on the closed track.

Remember that web publishes never appear as releases in Play Console. If all your fixes happen in Lovable, the test history looks idle – ship a few shell builds during the 14 days, even small ones. Our playbook on closed testing for AI-built apps covers recruiting and keeping testers engaged.

Policy forms the agent drafts and you submit

Play Console itemWhat the agent can prepareYour part
Data safetyAn inventory of collected data: Lovable Cloud accounts, user content, FCM tokens, crash data, text sent to AI modelsCheck it against reality and submit – see the Data safety guide
Account deletionThe in-app delete flow and a public web page for deletion requestsEnter the URL – see the deletion requirement
PaymentsA Play Billing bridge for digital goods, entitlements stored on the serverCreate products and decide where Paddle or Stripe still applies
App accessSeed data for a review accountEnter working credentials in Play Console
Webviews policyNative features and consistent brandingProve you own the domain the app shows

After each upload, read the pre-launch report: it installs the build on real devices and flags crashes, accessibility issues and security warnings. Hand its findings to the agent as tasks.

If you would rather not run Play Console yourself

Our AI Code Engineers handle the Play side in your own account: signing, CI/CD, the closed test set-up, the policy forms and the production release – see the Android submission service. Shipping to the iPhone as well? Lovable to the App Store with Claude Code or Codex covers the Apple side of the same setup.

Checklist: Lovable to Google Play with an agent

  • Developer account verified; closed-test planning started on day one for a new personal account.
  • Package name chosen deliberately – it can never change once the app is on Play.
  • The Android project lives in its own repository and loads your custom domain.
  • Back gesture, file uploads, edge-to-edge layout and Custom Tab sign-in tested on a real device.
  • targetSdk is 36, versionCode increases on every build and the upload key is not in the repository.
  • assetlinks.json lists the app signing key fingerprint from Play Console.
  • Data safety, account deletion URL, App access credentials and Play Billing are in place.
  • The pre-launch report for the release build shows no crashes.

Frequently asked questions

Can a cloud agent like Codex build my Android app?

Often yes, because Android builds run on Linux. The cloud environment must be able to install the Android SDK and download Gradle dependencies. Signing the release build and uploading it should still happen in your CI with secrets you control.

Is a Trusted Web Activity better than a WebView for Lovable?

A TWA is lighter but needs a proper PWA with a service worker, which Lovable does not set up for you, and offers fewer native hooks. A WebView shell gives the agent more control over uploads, sign-in and back navigation.

Do Lovable publishes count as updates during the closed test?

No. Play Console only sees the builds you upload. Web changes reach testers immediately, but they do not show up as releases, so plan a few shell builds during the test.

Can you handle the Play Console part for us?

Yes. Book a free call and an AI Code Engineer looks at your Lovable project and your Play Console status. We can take over signing, CI/CD, testing tracks, the policy forms and the release in your own account.

Free, 15 minutes, no obligation

Get your app from agent output to approved release.

Our AI Code Engineers take apps built with Claude Code, Codex, Cursor, Lovable, Base44 and co. through signing, CI/CD, store listings and review – in your own developer accounts.

AI tools, store policies and requirements change quickly – always check the current documentation of the tools and stores you use. This article is independent advice and not affiliated with or endorsed by Apple, Google, Anthropic, OpenAI or any other company or product mentioned; all trademarks belong to their owners.