App Store Connect for SwiftUI developers.

What SwiftUI developers specifically struggle with

The problem isn't competence — SwiftUI devs can absolutely get through App Store Connect. The problem is tone. Everything else in your pipeline feels fast and deliberate; App Store Connect feels like a different company's product.

• App Store Connect's web UI doesn't feel like an Apple product. It is built by Apple, but the experience — long scrolling forms, sluggish saves, full page reloads between tabs — is at odds with Xcode's tab/keyboard/command-palette culture.
• Keyboard navigation is broken. Tabbing between locales, jumping to a specific version, opening the app details panel — all require mouse work. If you are used to Command+Shift+O in Xcode, web ASC is a regression.
• The API is there but you don't want to write a client. The App Store Connect API exists, with JWTs and Swift packages. Writing a one-off Swift script to update keywords is fun once. Writing it for every metadata change is a second job.
• The Versions timeline loses context. In the web UI, each version is its own page with no cross-version view. Diff-ing release notes between 1.11.0 and 1.12.0 means opening two tabs and reading side by side.
• TestFlight is split across a different surface. Builds, groups, external testers, feedback — separate screens, each a page load away. After archiving you get taken through a three-step dance that could be one.

How AppConsul helps SwiftUI developers

Native macOS, written in Swift/SwiftUI

AppConsul is a real Mac app. Real windows with native full-screen, real keyboard navigation, real command palette, real toolbars. If you spend your day in Xcode, the muscle memory transfers: Command+N for new version, Command+S to save, Command+Shift+P for the command palette, slash for a quick search.

Command Palette for the entire App Store Connect surface

Command+Shift+P exposes every action across your apps: jump to an app, open a specific version, run a Guided Flow, run pre-flight checks, push a locale update, submit for review. Same idea as Xcode's Open Quickly — reach any surface in a few keystrokes instead of clicking through four sidebars.

Every locale in one editor with live UTF-16 counts

Apple's counts are UTF-16 code-unit based (so most single-codepoint emoji count as 2). AppConsul mirrors the same counting as the character counter, so your 30-character subtitle is the same in both places. Every locale you support lives in a column in the same editor — you don't open a form per locale.

Versions timeline you can actually read

Every version in chronological order with stage badges (Draft, Submitted, In Review, Approved, Live). Click a version to see its full state — attached build, release notes per locale, phased release setting, manual release toggle. Connect a GitHub repo and AppConsul can import release notes from tagged releases automatically, which is especially useful if your SwiftUI project uses semantic-version tags.

TestFlight integrated as a first-class surface

Internal and external groups, beta builds, expiring builds, tester invitations. One of the Guided Flows is specifically Set Up TestFlight Beta, which takes you through group creation, adding testers, and attaching the build you just archived from Xcode.

API keys in Keychain, not in a .fastlane folder

Your App Store Connect API key's issuer ID, key ID, and .p8 private key live in macOS Keychain. AppConsul calls Apple's API directly from your Mac — no relay servers, no third-party auth. Same security posture you'd design for yourself.

Recommended SwiftUI workflow

1. Build in Xcode. Archive and upload to App Store Connect from Xcode Organizer or Xcode Cloud.
2. Open AppConsul → Command+Shift+P → type your app name. Jumps straight to the app.
3. Versions → Command+N for a new version. Pick the newly-uploaded build from the build picker.
4. Metadata. All locales side by side. If this is a bug-fix release, copy-forward from the previous version's What's New and edit.
5. Store Assets (if UI changed). Reimport the live screenshots, replace what changed, upload diff.
6. Run pre-flight. Command+Shift+V (or click Pre-flight). AppConsul validates metadata, build attached, screenshots present, age rating set, privacy URL resolves.
7. Submit. Phased release toggle in the same panel. Confirm.
8. Work on the next feature while macOS notifications walk the version through the Apple review pipeline.

For TestFlight-heavy SwiftUI shops, the manage versions, builds, and TestFlight guide covers the internal/external tester split in more depth.

Tools you'll use most

• Metadata character counter — for drafting subtitle and description copy.
• Version and build number helper — maps the Xcode CFBundleShortVersionString and CFBundleVersion rules into something you don't have to re-read every release.
• API key validator — paste your issuer ID, key ID, and .p8 to confirm Apple accepts them before you try to connect.

Frequently asked questions

Is AppConsul built in SwiftUI?

AppConsul is a native macOS app written in Swift with SwiftUI for most of its UI. That's why the feel matches what you expect from an Apple-first developer tool: proper keyboard navigation, real sheets and toolbars, fluid scrolling — not a wrapped web view.

Does AppConsul have a command palette?

Yes. Command+Shift+P opens the command palette. Jump to an app, open a version, trigger a Guided Flow, re-run pre-flight checks — without leaving the keyboard.

Can I still use Fastlane alongside AppConsul?

Yes. Many SwiftUI developers keep Fastlane for build-and-upload from CI (Xcode Cloud, GitHub Actions, Bitrise) and use AppConsul for listing and submission work. They don't conflict — AppConsul picks up builds after Fastlane uploads them.

Does AppConsul work with Xcode Cloud?

Yes. Xcode Cloud uploads builds to App Store Connect the same way any other CI does. Processed builds appear in AppConsul's build picker on the Versions screen.

What about WidgetKit, App Intents, Live Activities?

Those are on the build side — they ship as part of your archived app. App Store Connect doesn't treat them specially at the listing level, so AppConsul doesn't need to either. Your listing, screenshots, and metadata are the same whether you use widgets, App Intents, or neither.