◉RORK LABJP
●MCP — Rork now lets you add and manage your own MCP servers inside Plugins (11/21)●2.5 ROUTE — From 12/1, apps calling gemini-2.5-flash are routed to 3.5 Flash-Lite and billed at its rates (9 days left)●CHANNEL — Users report Android notification channel reads and writes failing in Expo Go●NEW — New: three clues to check before replying to a stuck-on-splash review●EXPORT — Export your projects before you downgrade or cancel a plan●SONNET 4.5 — Apps that call Sonnet 4.5 through the API should switch before it retires on 11/30●MCP — Rork now lets you add and manage your own MCP servers inside Plugins (11/21)●2.5 ROUTE — From 12/1, apps calling gemini-2.5-flash are routed to 3.5 Flash-Lite and billed at its rates (9 days left)●CHANNEL — Users report Android notification channel reads and writes failing in Expo Go●NEW — New: three clues to check before replying to a stuck-on-splash review●EXPORT — Export your projects before you downgrade or cancel a plan●SONNET 4.5 — Apps that call Sonnet 4.5 through the API should switch before it retires on 11/30
Articles/Getting Started
◈ Getting Started/2026-08-19Beginner

You Cannot Shorten Review, But You Can Still Choose the Moment Your App Goes Live

Review time is out of your hands. The moment your app goes live, and how widely it spreads, is not. How the three App Store Connect release options, phased release, Google Play managed publishing and staged rollouts, and eas submit fit together — plus a table for when a submission stalls.

Rork620App Store93Google Play44Release5EAS Submit

The approval email arrived a little after three in the morning, my time.

I had submitted that version with "automatically release" still selected, so by the time I woke up the store listing had already flipped to the new build. My announcement post was still a draft. The replacement screenshots were scheduled for the next day. Nothing broke, and no user noticed — but the order of events had been decided by a review queue on the other side of the world rather than by me, and that detail stuck.

You cannot make review go faster. What you can do is stop treating "approved" and "live" as the same event. Both stores keep them on separate switches, and once you separate them, the unpredictability of the queue stops leaking into everything downstream.

This is written for anyone shipping a Rork-built app through EAS who keeps having announcements and screenshot swaps knocked out of order by an unpredictable review queue. Setting names and behaviour below are what I confirmed as of November 2026; store UI wording does change, so treat the labels as a guide rather than a contract.

Approved and live are two different switches

Here is what each store actually lets you control.

Aspect App Store Google Play
How long review takes Not under your control Not under your control
When an approved build goes live Three release options per version Managed publishing on or off
How widely it spreads once live Phased release (seven days, automatic updates only) Staged rollout (you pick and raise the percentage)
Where you set it The version page in App Store Connect Publishing overview in Play Console
Scope of the setting Per version — you pick it every submission Per app — set it once and it persists
Relationship to your submit tooling eas submit only uploads the build eas submit config has to agree with it

That last row is the one people miss. When you are shipping a Rork-exported project through EAS, it feels like eas.json should own the whole pipeline including the moment of release. It does not. The store-side setting sits above it, and changing only one of the two produces a mismatch that shows up as a failed submission rather than a helpful warning.

I added a row for how widely a release spreads, because that is a separate decision from when it goes live. Choosing the moment protects your announcement; choosing the spread limits the damage if something is wrong. You need both before "decide outside the queue" really holds.

App Store Connect asks you to choose again every submission

The version page in App Store Connect offers three ways to release.

Option What happens after approval When it fits
Automatically release this version Goes live as soon as review clears Quiet bug fixes with no announcement attached
Manually release this version Sits at "Pending Developer Release" until you press the button Anything you want to coordinate with a post or another store
Automatically release after a date Goes live after review, but no earlier than the date and time you set A launch date that was fixed before the build was ready

The third option takes a date and time in your own local time zone. If you are coordinating with an audience in another region, do that conversion once, deliberately, rather than assuming the field means what you want it to mean. It is an easy place to land several hours off target. Also note what the option actually promises: if review runs past your date, the build goes live the moment it is approved. It means "not before this date", not "exactly on this date".

My default is the manual option, for a plain reason: I do not get to choose what hour the approval lands. Review can clear at three in the morning or during a weekend. With manual release, an overnight approval simply waits. I open the store listing in the morning, look at it with my own eyes, and then publish — which keeps the announcement, the screenshots, and the build in the order I intended.

One practical caveat: this setting is stored per version, so the next submission starts fresh and you choose again. It is worth a line in whatever pre-submission checklist you keep, because it is exactly the kind of setting that gets skipped when you are focused on the build itself.

Where you press after choosing manual

Once approved, the version status becomes "Pending Developer Release" and a "Release This Version" button appears on the version page. Publication starts when you press it, but search and the product page can lag behind by a few hours. I time the announcement post to the moment I can see the new version in the App Store on my own phone, not to the moment I pressed the button.

Phased release is the other half of choosing the moment

Manual release lets you pick when. But if everyone receives the new build the instant you press the button, a bad release has nowhere to hide. That is what App Store phased release and Google Play staged rollouts are for.

Aspect App Store phased release Google Play staged rollout
Who receives it Existing users with automatic updates on The percentage of users you specify
How the share grows Automatically over seven days: 1%, 2%, 5%, 10%, 20%, 50%, 100% You set a number and raise it yourself
Stopping Can be paused, up to 30 days in total Can be halted
People who update by hand Get the new version immediately, regardless of phase Do not get it unless they fall inside the percentage

If I compress the choice into one line: announced updates get manual release plus phased release, quiet fixes get automatic release plus phased release, and only an urgent crash fix skips the phases and goes to everyone.

For a long time I treated phased release as excessive caution and left it off. Then one update crashed on launch for a specific group of older devices, and by the time I noticed, automatic updates had already delivered it to nearly everyone. It did not go well. Watching the review section fill up that fast is a feeling I would rather not repeat, and since then even quiet fixes go out phased.

On the Play side you can set the starting percentage from eas submit:

{
  "submit": {
    "production": {
      "android": {
        "serviceAccountKeyPath": "./secrets/play-service-account.json",
        "track": "production",
        "releaseStatus": "inProgress",
        "rollout": 0.05
      }
    }
  }
}

releaseStatus: "inProgress" makes it a staged rollout and rollout takes a fraction between 0 and 1 — here, 5%. Raising the percentage happens in the release page of Play Console. How long to wait before trusting the numbers from that first slice is its own question; what a 99.7% crash-free rate at the first 5% does and doesn't tell you covers how many users I waited for.

Turn on managed publishing before you need it

On the Play side, the equivalent control is managed publishing, and it is set per app rather than per release. With it enabled, changes that pass review collect in a "Ready to publish" list and stay there until you publish them yourself. With it disabled — the default — approved changes go live the moment they clear review.

The benefit that matters most in practice is not timing for its own sake. It is that store listing edits and app updates can be released together. Without managed publishing, a screenshot change can clear review in an hour while the binary is still being examined, leaving your listing describing a version nobody can download yet.

If you submit through EAS, there is one collision worth knowing about before you hit it. When Play Console already holds changes that have not been sent for review — which is the normal state once you work with managed publishing — a plain eas submit can collide with the automatic send-for-review step and stop with an error like this:

Google Api Error: Invalid request - Changes cannot be sent for review automatically. Please set the query parameter changesNotSentForReview to true. Once committed, the changes in this edit can be sent for review from the Google Play Console UI.

You resolve it by declaring the intent in eas.json:

{
  "submit": {
    "production": {
      "android": {
        "serviceAccountKeyPath": "./secrets/play-service-account.json",
        "track": "production",
        "releaseStatus": "completed",
        "changesNotSentForReview": true
      }
    }
  }
}

Setting changesNotSentForReview to true narrows the EAS step to uploading the artifact. Sending changes for review and publishing them both stay in Play Console, where managed publishing expects them to be. If you are going to use managed publishing, treat these two settings as a pair — enabling one without the other is the whole failure mode.

The reverse is also worth checking. With no pending changes in the console, a profile that still says true can fail the other way, with changesNotSentForReview must not be set; and when it does upload, the change waits in the publishing overview without entering review until you send it. Both are easy to inherit by copying an eas.json between a test app and a production app. In either direction, looking at what is sitting in the Play Console publishing overview resolves it faster than editing the config — in hindsight, I spent half a day doing those two steps in the wrong order.

When a submission or release stalls

Even with all of this in place, something occasionally stops. These are the cases I have actually run into, and how I check each one.

Symptom Likely cause How to check Fix
Approved but not live (iOS) Release option is manual Status reads "Pending Developer Release" Press "Release This Version"
Went live overnight (iOS) Submitted with automatic release Release option on the version page Add it to the pre-submission checklist
Scheduled release went out after the date The option means "no earlier than" Compare approval time with the scheduled time For fixed dates, submit several days earlier
eas submit fails with "Changes cannot be sent for review automatically" Unsent changes already in Play Console "Changes not yet sent for review" in the publishing overview Add changesNotSentForReview: true, send for review from the console
eas submit fails with "changesNotSentForReview must not be set" true with nothing pending The copied submit profile Remove the line from that profile
Upload succeeded, review never started (Android) Sent with changesNotSentForReview: true Changes waiting in the publishing overview Send them for review in the console
Passed review, not on Play Managed publishing is holding it "Publish changes" in the publishing overview Press it when the announcement is ready
Only some users get the new version Phased release or staged rollout in progress Phase day on iOS, percentage on Android Expand to everyone once it looks healthy

Three misunderstandings worth correcting

"Manual release makes review slower." It does not. The release option governs what happens after approval; it has no effect on queue position or review time. Both Apple and Google describe review time as something developers cannot speed up.

"During a phased release, some people can't get the update." Only half true on the App Store. Phased release throttles automatic updates; anyone who taps Update on the product page gets the new build from day one. Google Play staged rollouts really do exclude users outside the percentage, so the two stores differ here.

"If it's in eas.json, it controls the release timing." It controls how the upload is handled, nothing more. The iOS release option lives on the App Store Connect version page and managed publishing lives in Play Console. Write eas.json to match them, not the other way round.

When a deadline is fixed, start counting from before review

Controlling the moment of publication does not make review time predictable. For updates with an externally imposed date — a target API level requirement, a seasonal campaign, a partner announcement — you still need to work backwards, and the backwards count should start before the submission, not after it.

Three allowances I build in every time:

  1. Budget one full rejection round trip. Planning as if the first submission clears means a single piece of feedback consumes the entire buffer. Assuming one round trip and being pleasantly surprised costs nothing.
  2. Push a TestFlight external build through first. Distribution to external testers requires Beta App Review, which is a separate queue from the production App Review — and it is only required for the first build of a version. Getting it through early surfaces the things reviewers most often push back on, like permission usage strings and metadata, while you still have room to fix them. Internal testers on your team skip this review entirely, which is convenient but also means an internal-only test tells you nothing about how a reviewer will read your submission.
  3. Set your own submission deadline a few days ahead of the launch date. Without a hard "submitted by" date, small refinements expand to fill the time you were holding for the review queue.

If the deadline you are working against is on the Android side, the three places I had to fix before a Rork project actually targeted API level 36 covers what I actually had to change. And if the submission itself is rejected over a number rather than a policy, Version code 1 has already been used — who owns that number, app.json or EAS? is the closest neighbour to this article. Whether your limited time is better spent on external TestFlight testing or on a phased release is compared in TestFlight external beta vs. phased release for a solo developer.

The next thing that usually moves your date: replying to a rejection

Once you control the moment of release, rejections become the main thing that shifts your schedule — especially the vague ones, like a blank screen or an insufficient purpose string, where the message alone does not point at the cause. The common Expo release-build culprits are in what to check when App Review reports Guideline 2.1 and a blank screen. Reproducing the reviewer's screen on your own release build before replying usually saves a full round trip.

What you can change today

Two of these do not require waiting for your next submission.

Open Play Console and turn managed publishing on for the app you ship most often. If you submit through EAS, review changesNotSentForReview in the submit profile in the same sitting so it matches a workflow where you send changes for review from the console. Managed publishing is an app-level setting, so once it is in place it keeps working for every release after this one.

App Store Connect is the one you re-select each time. Adding a single line to your pre-submission checklist ("release option: manual, phased release: on") has been the only thing that reliably stops me from forgetting it.

The store decides when it is approved; I decide when it goes live and how far it spreads. While your build is sitting in the queue, there is very little left to do. If you take one thing from this, add that checklist line before your next submission — that is where I started too.

Share

Thank You for Reading

Rork Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

  • ✦Copy-paste ready implementation code
  • ✦New advanced guides published daily
  • ✦$5/mo or $10 for lifetime access
View Membership →

If you found this article helpful, a small tip ($1.50) would mean a lot to us. Your support helps keep this site ad-free and covers server and hosting costs.

Related Articles

◈ Getting Started2026-10-12
Before You Promise "Release in a Week" — Break Down the Days You Will Spend Waiting
When your Rork app is ready, the release date still isn't yours to set. Break the wait into Apple enrollment, Google Play closed testing, and first review, then work out the earliest and the late-case date with a small TypeScript script.
◈ Getting Started2026-08-22
The names you can change, and the ones you can't — the 30 minutes before your first Rork release
An app has three names, and only the display name can be changed after release. Here is how I check the identifiers Rork fills in by default, using a dependency-free script, before I hit submit.
◈ Getting Started2026-10-16
The night the Play Console wouldn't let me submit — release notes cap at 500 characters per language
Google Play release notes cap at 500 characters per language. A triage table for a stalled submission, a check script that also catches unclosed language tags (with real output), and why EAS Submit can leave draft releases behind.