◉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-22Beginner

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.

Rork620Expo237App Store93Google Play44bundleIdentifiergetting started

I noticed it while restructuring six wallpaper apps to build from a single codebase. Halfway through rewriting the build config, my hands stopped.

Two of the six had an android.package value that did not follow the naming rule the other four shared.

Those two were shipped back when I still thought I could tidy things up later. Tidying them up was no longer an option. By the time I noticed, years had passed, and the stores had long since stopped offering a way back.

An app has three names: the one shown in the store, the slug you use during development, and the identifier that tells the platform which app this actually is. Only the first one is truly free to change after release.

Rork fills in that identifier for you at generation time. Something that runs lands in your hands almost immediately, so it is easy to carry the default all the way to submission. The moment you register the app and upload a build, though, that string stops being yours to edit.

This piece is for anyone about to ship their first Rork app to the App Store or Google Play: which names cannot be walked back, and what to check in the thirty minutes before you register. Everything here reflects how App Store Connect, Play Console, and Expo behave as of November 2026.

After release, only the display name is still yours to change

Splitting the store-facing fields into changeable and fixed looks like this.

FieldApp StoreGoogle PlayChangeable later
Display nameChange with a new version reviewChange from the store listing (reviewed)Yes
Icon and screenshotsSwapped per versionSwapped from the store listingYes
Description and categoryChange with reviewChange from the store listingYes
Bundle ID / package nameLocked once a build is uploadedLocked once the first build is uploadedNo
SKUSet at registrationNot applicableNo
Store URLA numeric ID assigned at registrationThe package name appears directly in the URLNo

The last row is the one worth pausing on. On Google Play, the package name shows up verbatim in the store URL (play.google.com/store/apps/details?id=<package>). On Android, the identifier is not purely an internal concern — it is something people can see.

On the App Store side, you pick the bundle ID from a dropdown when you create the app record in App Store Connect. For a long time I assumed it stayed editable until I submitted for review. In practice, the first uploaded build ties it to the record for good — and that includes a build you uploaded only to try TestFlight.

Signing keys are a different story: on Google Play you can request an upload key reset from Play Console. I'd keep keys and names in separate mental boxes, because lumping them together makes it easy to give up on a problem that is actually fixable.

The three names live in different places

Mapped onto the app.json that Rork exports, the three names look like this.

Nameapp.json fieldWhat it controlsIf you change it later
Display nameexpo.nameThe label under the home-screen icon (the store name is entered separately)Applies from the next build
Slugexpo.slugThe project URL on Expo / EASBreaks the link to your EAS project
Identifierios.bundleIdentifier / android.packageHow the OS and the stores tell apps apartThe store treats it as a different app

The slug in the middle is the one people miss. Store users never see it, but the first time you run EAS Build, a project ID is written to extra.eas.projectId and paired with the slug. Change the slug alone after that, and the build stops before it starts with something like this:

Slug for project identified by "extra.eas.projectId" (xxxxxxxx-...) does not match the "slug" field (new-slug).

The pattern I see most often is someone renaming the app, then tidying the slug to match, then hitting this wall. Change the display name; leave the slug and the identifier alone, and this class of failure simply does not happen.

The identifier Rork writes is often still a placeholder

The app.json (or app.config.ts) in a project Rork exports can contain something like this:

{
  "expo": {
    "name": "wallpaper",
    "slug": "wallpaper",
    "ios": { "bundleIdentifier": "com.anonymous.wallpaper" },
    "android": { "package": "com.anonymous.wallpaper" }
  }
}

Anything starting with com.anonymous. is the placeholder Expo fills in when no identifier was given. As generated output it is perfectly valid: it builds, it installs on a device, it runs. Because it works, nothing prompts you to question it.

Replacing it with something of your own is not complicated:

  • If you own a domain, put it first, reversed (dolice.net becomes net.dolice.)
  • If you do not, anchor it to an account that actually exists (io.github.<username>. and similar)
  • End with a short word that names the product

What I would avoid is anything whose meaning drifts. Tack free, v2, 2026, or ios onto the end, and the day you make the free app paid or rebuild it from scratch, the identifier keeps pointing at a decision you no longer hold. I did exactly this once, and it shaped the naming of everything I shipped after it.

One more thing: bundle IDs are unique across all of Apple's developer accounts. If another team already holds a string, you cannot register it, and Xcode or EAS credential setup answers with "An App ID with Identifier '…' is not available." Avoiding com.<common word>.<common word> is not just about looks.

Check it mechanically, before you register

Eyeballing these strings stops being reliable somewhere around the sixth app. So I now run the script below before every submission. It has no dependencies; Node 18 or later is enough.

// check-app-ids.mjs
import { readFileSync, existsSync } from "node:fs";
 
const RESERVED = new Set(["abstract","assert","boolean","break","byte","case","catch",
  "char","class","const","continue","default","do","double","else","enum","extends",
  "final","finally","float","for","goto","if","implements","import","instanceof","int",
  "interface","long","native","new","package","private","protected","public","return",
  "short","static","strictfp","super","switch","synchronized","this","throw","throws",
  "transient","try","void","volatile","while"]);
 
const PLACEHOLDER = [/^com\.anonymous\./i, /^host\.exp\./i, /^com\.example\./i,
  /\byourname\b/i, /\byourcompany\b/i, /\bmyapp\b/i, /\btest\b/i];
 
function readConfig(path) {
  if (!existsSync(path)) return null;
  const raw = JSON.parse(readFileSync(path, "utf8"));
  return raw.expo ?? raw;
}
 
function checkAndroidPackage(pkg) {
  const errs = [];
  if (!pkg) return ["android.package is not set"];
  const segs = pkg.split(".");
  if (segs.length < 2) errs.push("fewer than two dot-separated segments");
  for (const s of segs) {
    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(s)) errs.push(`segment "${s}" must start with a letter`);
    if (RESERVED.has(s)) errs.push(`segment "${s}" is a Java reserved word`);
  }
  return errs;
}
 
function warnAndroidPackage(pkg) {
  // Uppercase is legal on Android but unconventional, so this only warns
  return (pkg ?? "").split(".").filter((s) => /[A-Z]/.test(s))
    .map((s) => `segment "${s}" contains uppercase (lowercase is the convention)`);
}
 
function checkBundleId(id) {
  const errs = [];
  if (!id) return ["ios.bundleIdentifier is not set"];
  if (!/^[A-Za-z0-9.-]+$/.test(id)) errs.push("contains characters that are not allowed");
  if (id.split(".").length < 2) errs.push("fewer than two dot-separated segments");
  if (/_/.test(id)) errs.push("underscores are not allowed");
  return errs;
}
 
const path = process.argv[2] ?? "app.json";
const cfg = readConfig(path);
if (!cfg) { console.error(`x ${path} not found`); process.exit(2); }
 
const ios = cfg.ios?.bundleIdentifier;
const android = cfg.android?.package;
const findings = [];
 
for (const e of checkBundleId(ios)) findings.push(["BLOCK", "ios.bundleIdentifier", e]);
for (const e of checkAndroidPackage(android)) findings.push(["BLOCK", "android.package", e]);
for (const e of warnAndroidPackage(android)) findings.push(["WARN", "android.package", e]);
 
for (const [key, val] of [["ios.bundleIdentifier", ios], ["android.package", android]]) {
  if (val && PLACEHOLDER.some((re) => re.test(val))) {
    findings.push(["BLOCK", key, `"${val}" looks like an untouched placeholder`]);
  }
}
if (ios && android && ios.toLowerCase() !== android.toLowerCase()) {
  findings.push(["WARN", "ios/android", `identifiers differ (iOS: ${ios} / Android: ${android})`]);
}
if (!cfg.name) findings.push(["WARN", "name", "display name is not set"]);
if (!cfg.slug) findings.push(["WARN", "slug", "slug is not set"]);
 
console.log(`# ${path}`);
console.log(`  ios  : ${ios ?? "(none)"}`);
console.log(`  and  : ${android ?? "(none)"}`);
if (findings.length === 0) { console.log("ok - safe to lock in"); process.exit(0); }
for (const [lv, key, msg] of findings) console.log(`  [${lv}] ${key}: ${msg}`);
process.exit(findings.some(([lv]) => lv === "BLOCK") ? 1 : 0);

There are three things it looks for: a placeholder that was never replaced, an Android package segment that will not compile, and iOS and Android identifiers that have drifted apart.

The second deserves a word. Expo uses android.package not only for Gradle's applicationId but also as the package (namespace) of the generated native code. Put a Java reserved word such as new or class in a segment, and there are reports of the generated sources failing to compile even though the config looks entirely reasonable. Nothing about the error points you at the package name, so the script treats it as a blocker.

Uppercase is different. Android's rules allow it; lowercase is only the convention. So that one is a warning, not a stop.

Here is the output from four configs I ran it against:

$ node check-app-ids.mjs a-default.json
# a-default.json
  ios  : com.anonymous.wallpaper
  and  : com.anonymous.wallpaper
  [BLOCK] ios.bundleIdentifier: "com.anonymous.wallpaper" looks like an untouched placeholder
  [BLOCK] android.package: "com.anonymous.wallpaper" looks like an untouched placeholder
exit=1
 
$ node check-app-ids.mjs b-mismatch.json
# b-mismatch.json
  ios  : net.dolice.calmwall
  and  : net.dolice.calm_wall
  [WARN] ios/android: identifiers differ (iOS: net.dolice.calmwall / Android: net.dolice.calm_wall)
exit=0
 
$ node check-app-ids.mjs c-reserved.json
# c-reserved.json
  ios  : net.dolice.new.zentimer
  and  : net.dolice.new.zentimer
  [BLOCK] android.package: segment "new" is a Java reserved word
exit=1
 
$ node check-app-ids.mjs d-ok.json
# d-ok.json
  ios  : net.dolice.zentimer
  and  : net.dolice.zentimer
ok - safe to lock in
exit=0

The second case is a WARN rather than a BLOCK on purpose. calm_wall is a perfectly legal Android package name; underscores are only rejected on the iOS side. A mismatch there is sometimes the residue of trying to keep the two aligned, and that is not something a script can adjudicate for you. So it reports and steps aside.

Because it exits with a status code, you can add "precheck": "node check-app-ids.mjs app.json" to the scripts in package.json and run npm run precheck whenever you like. If you use app.config.ts, write out the resolved config first with npx expo config --json > resolved.json and pass that file instead.

When registration or upload stops on a name

Name-related failures rarely say "this is about your name." These are the ones I have hit myself or seen others ask about, arranged so you can look them up by symptom.

SymptomLikely causeHow to confirmFix
"An App ID with Identifier '…' is not available."Another team already registered that bundle IDCheck whether it appears under Identifiers in your Apple Developer accountIf no build is uploaded yet, pick a different string and register again
Play Console says a name like "com.example" is restrictedYou are uploading with a placeholder package nameLook at the start of android.packageSwitch to your reversed domain and rebuild
A second AAB is rejected for having a different package nameYou changed android.package after the first uploadCompare with the package name shown in your Play Console app listRevert app.json to the original value — it cannot change for that app
EAS Build will not start because of a slug mismatchYou renamed the slug along with the display nameCompare extra.eas.projectId and slugRestore the slug and change only the display name
Only the Android build fails with a compile errorA package segment is a reserved wordSee whether the script above reports a BLOCKReplace the segment before anything reaches the store

The third row is the only one where the fix is "go back." Every other row is recoverable as long as you have not shipped. That difference is, I think, the whole reason to check things in a fixed order.

Three misunderstandings worth clearing up

"If I delete the app, I can recreate it under the same identifier." You can't. App Store Connect states that a bundle ID used by an app cannot be reused even after that app is removed. On Google Play, package names are unique and permanent; deleting an app does not free its name for another one. Choosing a new identifier is faster than hunting for a way to reclaim the old one.

"iOS and Android must share the same identifier." They don't have to. They are separate systems, each managed by its own store. Matching them is simply convenient when you read logs or billing dashboards — which is why the script only warns on a mismatch.

"Renaming the app makes the store treat it as a new one." It doesn't. Ratings, reviews, and install history stay attached to the identifier. If all you want is a new name, there is no reason to republish.

If you plan to ship more than one, settle the rule first

Even if you only intend to ship one app, a build that goes well tends to produce a second. What carries over is the naming rule you set on the first.

Across my six apps I use two or three segments only: <reversed domain>.<short product name>. No platform, no version number, no distribution model. The more meaning you load into an identifier, the more of it becomes stale and unmovable.

There is a second, less obvious benefit. When every app follows the same shape, you can derive the identifier from a single variable in your build config rather than hand-writing it per app. A rule that a script can reproduce is a rule you cannot mistype at two in the morning, which is roughly when I have historically done my worst naming.

Load whatever you like into the display name instead. That one you can change later. Put information that changes where change is allowed, and only stable information where it is not — that split is what has held up best for me.

If you have already shipped

Some of you will be reading this after the fact. There are two paths, and they compare like this.

Keep the identifierRepublish under a new one
Ratings and reviewsStayStart from zero
Auto-updates for existing usersContinueStop (you need to steer people to the new app)
In-app purchase productsUnchangedRecreated on the store side
EffortAlmost noneListing, review, and announcement all over again
When it fitsThe mismatch is only visible to youOnly a handful of reviews, and the name contains something misleading

Keep it. Outside the Android store URL, the identifier is almost never visible to the people using your app. Changing the display name resolves the cosmetic side of it. Two of my six still carry the off-pattern identifier for exactly this reason — the mismatch is the kind of thing only I will notice, years from now.

Republish under a new identifier. Code and assets come with you; the path from the old app to the new one is something you have to build yourself.

For me the deciding factor is the review count. With a handful of reviews the cost of republishing is small; once you are into the hundreds, living with an untidy identifier is almost certainly the better trade.

The next thing that sticks: whose name is on the account

Once the identifier is settled, the next question most people hit is whether to enroll in the Apple Developer Program as an individual or as an organization. The seller name shown in the store comes from the account, and like the identifier, it is not something you casually change later.

The Apple-side steps Rork cannot do for you are laid out in order in The Apple-side setup Rork cannot do for you before your first release. If you have already shipped as an individual and want to move to an organization, Can you move an iOS app from an individual account to an organization later? covers what to clear first. An App Transfer keeps the app's identifier as it is, so the first naming decision follows you there too.

The thirty minutes before you register

  1. Open app.json or app.config.ts and look at ios.bundleIdentifier and android.package
  2. Run the script above and fix everything until the BLOCK count reaches zero
  3. Re-read the tail of the identifier for anything like free, v2, 2026, or ios
  4. Decide now that a future rename touches the display name only, never the slug
  5. Write down, in a single line, how you would extend the rule for a second app

Do all five before you create the records in App Store Connect and Play Console and upload a first build. In the other order, the things you could have fixed are no longer fixable.

The day you ship your first app is crowded with decisions, and quiet fields like a name tend to slide to the end of the list. Mine did. If you do only one thing today, open your app.json and make sure com.anonymous. is not still sitting there.

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-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.
◈ 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-19
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.