Publish a Rork App to Google Play: AAB and 12 Testers

Short answer: Rork builds the signed AAB, Play Console decides your launch date

Rork builds native Android apps in Kotlin with Jetpack Compose, and its Publish menu does the store-facing build for you: Publish → Google Play → Connect Google Play → Build AAB for Play. The bundle is signed with an upload key Rork keeps stable for the project. When the build finishes you can let Rork upload it or download the .aab and put it into Play Console yourself — the file is the same either way. Rork's own confirmation tells you where it landed: "Version 1 is in internal testing. It isn't public yet."

That upload is the easy part. If your Play Console account is a personal one created after 13 November 2023, Google requires that you "run a closed test for their app with a minimum of 12 testers who have been opted in continuously for at least 14 days" before you can apply for production access (Play Console Help). Nothing about how the app was built changes that. Rork ships the bundle to internal testing first, the internal track does not count toward the requirement, and the 14-day clock only runs once the release sits on a closed test and 12 real testers have opted in.

What Rork actually gives you for Android

An Android app in Rork is a native Kotlin app with Jetpack Compose — not a browser page in a shell, and not the iPhone build converted at runtime. The stack matters for publishing because it decides where your bundle comes from. Rork's documentation is explicit that the old route is gone for new work: "You can no longer create Expo (React Native) projects in Rork." Rork used to build Expo (React Native) apps, and existing Expo projects keep building and publishing, but new projects are native. The practical consequence: your Android bundle comes out of Rork's own Publish menu, not out of an EAS build you run yourself. Guides that still tell you to run npx eas-cli build --platform android against a Rork project are describing a workflow Rork retired.

An iPhone-only Rork project cannot reach Google Play at all. Rork's publishing docs state plainly: "An iPhone (Swift) app cannot go to Google Play." To get there you add an Android app to the same project, which creates a second, separate Kotlin codebase that shares your backend, your chat, and the Publish menu. One project, two codebases — a change made for one platform is not automatically in the other, so updates that ship from Rork still need to be made in the app you are actually testing on Android.

Publishing is not on Rork's free plan: the Free tier is design-only, and Rork's pricing documentation states "Building and publishing an app needs Rork Pro ($20/mo) or Rork Max (from $200/mo)." Google's fee is a separate bill — Rork's own account guide notes that "Google charges a one-time $25 registration fee," charged once, whether you publish one app or many.

What Rork leaves to you in Play Console

Rork handles the artifact, not the account. Its documentation is direct about where the boundary sits: "Google's API cannot create the first app record for you, so the listing has to exist in Play Console before Rork can publish to it." Everything that constitutes the app's presence on Play — and everything Google reviews — stays manual:

• Creating the app record: name, default language, app or game, and the free-or-paid choice
• The store listing: title, description, icon, feature graphic, screenshots
• Content rating, data safety, and the policy questionnaires
• Adding testers to the closed track and sharing the opt-in link
• Sending releases for review and promoting them between tracks
• Answering the production access application once the 14 days are up

The order Rork recommends front-loads the slow parts: register the developer account and start identity verification on day one, build and try the app on your own phone, create the Play Console record, let Rork send the first build to internal testing, then start the closed test while you finish the listing. Rork's guide gives the reason for starting with the account: "Google's checks take days, not minutes."

Step 1: Create the Play Console app record before Rork uploads

Rork cannot make the first app record, and it will not send a build until one exists: "Rork needs the app to already exist in Play Console before it can send a build." Create the app in Play Console first, then connect Rork's Publish panel to the Google account that manages that record. If Rork's panel offers Create Play Console app, that is the signal you skipped this step.

Two fields in the creation dialog are permanent. The package name is one: Google documents that "Once you upload an artifact, the package name for that app is fixed and cannot be changed," and Rork's walkthrough tells you to use Play Console's Copy package name so the record matches the build. Get the record and the build out of sync and you are not correcting a setting — you are starting over with a new app record, a new listing, and a new closed test.

The price model is the other permanent field. Google lets you move one way only: "You can change your app from paid to free," but "Once your app has been offered for free, the app can't be changed to paid." Rork flags the same trap inside its own walkthrough: "If you intend for this to be a paid app, make sure that it's marked paid now." Decide before the first upload, not after the test.

Step 2: Build the AAB in Rork and get it into Play Console

Open Publish → Google Play, click Connect Google Play, sign in with the account that manages the app, then click Build AAB for Play. When the build finishes you get two choices: Send to Google Play, which "uploads the AAB to your internal testing track for you," or Download AAB for Play Console if you would rather drag the file into a release yourself. Either route ends at the same place — a signed bundle sitting on the internal testing track.

Two Play-side behaviors are worth knowing on the first upload. Internal testers see a temporary name and store listing for a while: "First-time app uploads are available immediately to internal testers, displaying temporary name and store listing information for up to 48 hours." And the link itself can lag — "After publishing an open, closed, or internal test for the first time, the test link can take several hours to become available to testers." For updates later, the loop is the same as the first build: change it in Rork, Rebuild AAB, send it again with a higher version code.

Step 3: Get the release off internal testing — the Rork-specific trap

Rork's first destination is always internal testing, and internal testing is a smoke-test track: it needs no completed app setup, its releases are exempt from the Data safety section, and it does not count toward the tester requirement. Rork says so itself — "Internal testing does not satisfy Google's 12-testers-for-14-days rule." Use it to install your own build and check nothing crashes, then move the release to a closed test, either in Play Console or by asking the Rork agent to Promote this release to closed testing.

The trap is who touched internal testing first. Google documents that "A user who opts into your app's internal test is no longer eligible to receive an open or closed test. To access an open or closed test, the user must first opt out of the internal test and then opt in to the open or closed test." Twelve people who installed your app from an internal link are twelve people who must now opt out before their closed-test clock can start — and their 14 days count from the moment they opt in to the closed track, not from when they first installed.

Set the release on the closed testing track, add your testers by email list or Google Group, and send the opt-in link. Two Play Console conditions explain most zero counts: the opt-in link only appears when the app's status is Published — "The opt-in link displays only when an app status is 'Published'" — and the first link can take hours to materialize. If your closed count is still at zero after sharing, work the 0-testers fix list before you recruit anyone new.

Step 4: Run the 14 days with 12 testers who stay in

Google checks the state of the track at the moment you apply: "At least 12 testers must be opted in to your closed test when you apply for production access, and they must have been opted in continuously for the preceding 14 days." Continuity is counted per tester — "Testers who opt in, test for fewer than 14 days, and then opt out do not count toward the requirement" — so one departure from a track of exactly twelve moves your application date. That is the reason most builders run a small buffer above the minimum.

Opted in is the count; engaged is what the application form asks you to describe. The daily-usage explainer covers what activity looks like during the window, the uninstall article covers what happens when someone removes the app without opting out, and your choice of tester list changes how easily you can chase a dropout mid-test.

On recruitment, Google's own advice starts with people you know — friends, family, colleagues, classmates — plus communities where your future users already are. Rork points its builders at its own community: its store guide tells you to ask in the Rork Discord, where founders swap testing. Swap partners are a real option with a known failure mode — people leave — so the practical question is how you replace a dropout the day it happens, and the paid-service comparison lays out when paying for coordination is worth it.

Step 5: Apply for production access and publish

With the criteria met, Apply for production appears on the Dashboard. The form has three sections — 'About your closed test', 'About your app/game', and 'About your production readiness' — and the first one is where the previous two weeks get spent: how easy recruitment was, whether testers used all available features, how usage compared with expected production behavior, and a summary of the feedback you received and how you collected it. The form-questions walkthrough covers what to write in each field.

Google states that "Review usually takes seven days or less, but can occasionally take longer," and the outcome arrives by email. If the answer is more testing, Google names two reasons — "fewer than 12 opted-in testers or insufficient tester engagement during the testing period" — and the rejected-app guide covers how to read the decision and restart. If the Apply button never appears at all, the button-missing guide runs the causes.

One pre-application check deserves its own line for Rork projects, because many of them ship with sign-in — Rork Auth, Supabase, or Firebase. Google requires working credentials for exactly that case: "If your app requires user authentication, provide valid, working login credentials in Play Console so reviewers can fully test your app's features." The test-credentials guide shows where to put them.

What can still get a Rork app rejected

A bundle that validates is not an app that is ready. Google's pre-application checklist covers app content and features, targeting and content rating, functional reliability, and test credentials, and it warns that "Google evaluates production apps for policy adherence, but review is not a troubleshooting step." The failures that show up on Rork-built apps are specific enough to list:

• A sign-in wall with no test credentials — the Rork-app version of the reviewers-cannot-log-in problem
• Content rating, data safety, or policy questionnaires left incomplete — Rork does not fill these in for you, and the Data safety exemption that applies on internal testing disappears once the app moves to a closed track
• Package name mismatch between the Play record and Rork's build — a permanent field with no fix other than a new record
• Testers still opted into internal testing — they cannot count on the closed track until they opt out first
• Engagement that stops after the first install — the application form asks what testers did, not how many downloaded
• Track limits inside Rork's agent: promotion works across internal, closed, open, production, and staged rollouts, but "custom testing tracks are not supported yet," and there is no rollback — a bad release is halted or replaced with a corrective one

Every item on that list is cheaper to fix before you apply than after a rejection, and none of them are Rork bugs — they are the manual work Rork's documentation tells you to expect.

FAQ

Does a Rork app need 12 testers for 14 days? Yes, if your Play Console account is a personal one created after 13 November 2023. The requirement is scoped to the account, not to how the app was built — Rork's role ends at producing and uploading the AAB.

Can Rork submit my app to Google Play for me? Partly. It builds, signs, and uploads the bundle and can promote releases between tracks from chat. The app record, the listing, the policy questionnaires, the tester opt-ins, and the production access application are done by you in Play Console.

Do I need Android Studio or my own keystore? No. Rork signs the bundle with a persistent upload key it manages for the project. The one thing you must not do is ask the agent to add new signing keys, keystores, or SHA1 fingerprints — the first upload fixes the key Play will accept.

Is a Rork Android app just a wrapped website? No. Rork Android apps are Kotlin with Jetpack Compose, a native codebase of the kind a hand-written Android app uses. The Play bundle you upload is a standard Android App Bundle, no different in form from one built in Android Studio.

Why do my testers see nothing after Rork uploads? The first upload lands on internal testing, the test link can take hours to appear, and the opt-in link only shows when the app's status is Published. Also check that your testers are not stuck opted into the internal test from an earlier link — they must opt out before they can join the closed test.

Can I change the package name after the first upload? No. Google fixes the package name once an artifact is uploaded, so the record you create before Rork's first build is the one you keep. Use Copy package name in Play Console and make the build match it.

How much does it cost to get a Rork app onto Google Play? Two separate bills: Rork's plan, because building and publishing needs Rork Pro or Rork Max, and Google's one-time developer registration, which Rork's own guide puts at a one-time $25 fee. The 14-day test itself costs nothing beyond the testers you choose.