From Idea to the App Store

Most app ideas never reach the App Store. Not because the idea is bad, but because the distance between "I have a concept" and "it's live" is a swamp of boilerplate, consoles, plists, and review rules. ShipThatApp collapses that distance: the undifferentiated heavy lifting is already built and battle-tested, so the only thing left for you to build is the part that makes your app yours.

This page is the map of the whole journey, in three acts: start with an idea, make it yours, ship it. Each act links out to the page that does the work — this is the connective overview, not the detail.

The Journey at a Glance

  ACT 1 — START WITH AN IDEA          ACT 2 — MAKE IT YOURS              ACT 3 — SHIP IT
  ──────────────────────────         ──────────────────────────        ──────────────────────────
  Pre-built blocks:                  Rename project + bundle id         Archive + export the IPA
    • Auth (Apple / Supabase)        Production Config.xcconfig         Attach build to a version
    • In-App Purchases               Prod Supabase + delete-account     Submit for review
    • On-device + cloud AI           Prod RevenueCat + products         Monitor until "Ready"
    • Dex scanner                    Production AI proxy
    • Analytics, onboarding          Camera string + App Privacy
                                     Production entitlements
        │                                     │                                  │
        └──── build YOUR feature ─────────────┴──── two ways: console or CLI ─────┘

The three acts are sequential, but only Act 1 is really "yours to invent." Acts 2 and 3 are mechanical — and Act 3 is fully scriptable.

Act 1 — Start With an Idea

The whole premise of ShipThatApp is that you should spend your time on your unique feature, not on rebuilding the same login screen, paywall, and API plumbing every app needs. The kit hands you those blocks already wired together and production-grade:

• Authentication — Sign in with Apple (with a nonce), email/password, and Magic Link through a single @Observable AuthManager, including the in-app account deletion reviewers require. See Authentication.
• In-App Purchases — RevenueCat on top of StoreKit, three ready-made paywalls, entitlement gating, and a working Restore Purchases flow. See In-App Purchases.
• On-device + cloud AI — ChatGPT, DALL·E, and Vision, every cloud call HMAC-signed through a backend proxy so your OpenAI keys never ship in the binary. See AI Chat.
• The Dex scanner — a flagship hybrid feature: instant on-device Apple Vision classification plus a rich, structured cloud identification pass, persisted in its own SwiftData store. See Dex Scanner.
• Analytics, onboarding, settings, splash, review prompts — the supporting cast every shipping app needs, already in place.

Start at the Introduction for the full tour, then pick the blocks your idea needs and build the one thing only you can build on top of them.

Act 2 — Make It Yours

Once the feature works on your simulator, the app still wears the template's identity and points at demo backends. "Making it yours" is the configuration pass that turns a clone into your product, ready for review.

• Rename everything — project, scheme, target, bundle identifier, and the auth URL scheme. The placeholder identity is app.shipthat.demo with the scheme shipthatapp; everything downstream (signing, push, deep links) keys off these. Follow Rename Xcode Project.
• Move secrets to production — every key lives in the gitignored Config.xcconfig, never in a Swift file. Fill it with your production Supabase, RevenueCat, and proxy values. The full key reference is in Configuration & Secrets.
• Stand up production backends — a real Supabase project (with the delete-account Edge Function deployed), production RevenueCat with App Store Connect products replacing the demo productIds/subGroupId in Config.swift, and your AI proxy deployed so OpenAI keys stay server-side.
• Privacy and entitlements — add the NSCameraUsageDescription the scanner needs, fill out App Privacy to match the bundled PrivacyInfo.xcprivacy, and flip push/associated-domains/app-group entitlements to production.

All of this — every step, every gotcha, and the review traps that sink boilerplate apps (account deletion, Restore Purchases, the camera string, demo credentials) — is covered in depth in the manual checklist:

Act 3 — Ship It

With a renamed, production-configured app, shipping is a fixed pipeline:

  bump version/build  →  archive  →  export IPA  →  attach to version  →  submit for review  →  monitor

You can drive that pipeline two ways.

Two ways to ship: the console, or the command line

• The console. Archive in Xcode, then click through App Store Connect in the browser — validate, upload, add to TestFlight, fill in metadata, submit. This is the path the Shipping to the App Store checklist walks, and it's the right starting point the first time so you see every screen.
• The command line. Once you've shipped once and understand the moving parts, the same pipeline becomes a handful of scriptable, repeatable commands with the asc CLI — no browser, automatable in CI, identical on every release.

The command-line track maps one-to-one onto the manual flow. As a taste, a release is bounded by an authenticated session at the start and a single canonical publish command at the end:

# Authenticate once (stores an App Store Connect API key in the keychain)
asc auth login --name "ShipThatApp" --key-id "ABC123" --issuer-id "DEF456" --private-key ./AuthKey.p8
asc doctor

# ...build, export, then ship the whole thing in one command:
asc publish appstore --app "app.shipthat.demo" --ipa app.ipa --version "1.0.0" --submit --confirm

# ...and watch the release pipeline until it lands:
asc status --app "app.shipthat.demo"

The asc track is split across three pages, in pipeline order:

• asc CLI — Automating the Release — install, authenticate (asc auth login, asc doctor), the env-var fallback, and the command vocabulary you'll reuse everywhere.
• asc — Build & TestFlight — version bumping, local archive/export (asc xcode version, asc xcode archive, asc xcode export), and TestFlight distribution (asc publish testflight, asc builds list).
• asc — Metadata & Submit — readiness checks (asc validate), staging metadata (asc release stage), the canonical asc publish appstore --submit --confirm, and monitoring with asc status.

Where to Go Next

• Inventing the feature? Start at the Introduction and the feature pages: AI Chat, Dex Scanner, Authentication, In-App Purchases.
• Configuring for production? Work the Shipping to the App Store checklist, with Rename Xcode Project and Configuration & Secrets alongside it.
• Automating the release? Begin with the asc CLI, then asc — Build & TestFlight and asc — Metadata & Submit.