Help Center

How LaunchLayer works

Plain-English guidance for the Release Command Center, source preparation, existing builds, store setup, QA, cloud builds, deployment, and recovery.

Complete integration guide

Understand exactly how LaunchLayer wraps, builds, automates, and deploys

Start with the end-to-end workflow, then go deeper into the native wrapper, automation and AI boundaries, signing, store deployment, updates, security, and evidence-based troubleshooting. Current, beta, planned, and external responsibilities are kept distinct.

Open the full guide
Store Launch Advisor

Get a launch path tailored to your app

Answer the release questions LaunchLayer actually needs before it can safely guide Apple, Google, signing, in-app payments, testing, submission, or troubleshooting.

Question 1 of 70% complete

Which store are you preparing for?

Choose both if the same app will ship on iOS and Android.

Complete LaunchLayer guide

LaunchLayer from source to store — the complete workflow

The full release lifecycle in one place, including what LaunchLayer automates, what happens in external services, and where human review is still required.

1. Start with the real input

Create a project from the material you actually control: a live HTTPS web app, GitHub repository, source ZIP, existing signed IPA/APK/AAB, or an existing store application. Source paths can support rebuild-oriented work; signed binaries are for inspection and supported upload workflows, not source recovery.

2. Inspect before changing anything

LaunchLayer records project identity, source evidence, framework/build hints, identifiers, versions, assets, credentials, and provider state. It uses those facts to determine the safest next action instead of assuming every project follows the same path.

3. Configure the native shell

For supported wrapper projects, LaunchLayer prepares Capacitor-oriented configuration, native capability requirements, store metadata guidance, permission copy, dependency/setup instructions, and release checklists. A generated plan is not the same as completed app-specific implementation or device verification.

4. Prepare signing and store connections

Apple and Google release builds require the correct developer accounts, app identifiers, signing material, store records, and permissions. LaunchLayer can validate and use configured credentials for supported operations, but Apple, Google, GitHub, RevenueCat, Firebase, and other providers remain independent systems with their own rules.

5. Build using the path your project supports

Legacy hosted-wrapper cloud builds use generated GitHub repositories and GitHub Actions. Existing signed binaries can move to inspection and supported direct-upload flows. GitHub/ZIP Source Build V2 currently performs controlled inspection/readiness work; arbitrary-source V2 compilation remains disabled until its isolated runner boundary is released.

6. Validate before upload

LaunchLayer checks release identity, signing/readiness evidence, required assets and metadata, and known mismatch conditions. Passing LaunchLayer checks reduces preventable mistakes but does not mean Apple or Google will approve the app.

7. Upload and monitor

Supported deployment flows upload an already built, correctly signed artifact to the matching store application, preserve job history, surface provider processing state, and keep retry attempts separate. Store processing, declarations, testing tracks, review, rollout, and publication remain controlled by Apple or Google.

8. Repeat for every release

A new version normally means re-inspecting changed source or a new binary, updating version/build identity, regenerating or rebuilding when native inputs changed, validating again, and then uploading the new artifact. LaunchLayer is a release workspace; it does not make a previously signed binary self-updating.

Release Command Center: check everything before you ship

Production

Use one project-wide preflight to understand readiness, blockers, next build identity, and the safest next action without hunting across every release tab.

What it is

The Release Command Center sits near the top of every project and turns LaunchLayer release evidence into one plain-language status: Ready, Working, Needs you, or Blocked. It is the recommended starting point when you return to a project or are unsure what to do next.

Check everything

Check everything runs a server-side deterministic preflight across the project evidence LaunchLayer already records. Depending on platform and project path, checks include bundle or package identity, build configuration identity, exact store-app matching, store connections, deployment credentials, signing readiness, icon and screenshot evidence, store metadata, privacy confirmation, latest artifact identity, unresolved rejections, and active background jobs.

Launch readiness score

The percentage is a progress signal derived from the current preflight checks. It is not an Apple or Google approval score and does not predict App Review or Play policy decisions. Review-only recommendations are kept separate from deterministic blockers.

Next safe build number

LaunchLayer calculates a suggested next build number from the recorded project, configuration, build artifact, and deployment build numbers. This helps avoid accidentally reusing a recorded build number, but the target provider remains authoritative if it has newer build history that LaunchLayer has not yet observed.

Smart Fix Center

Unresolved checks are grouped into one expandable Smart Fix Center. Take me there opens the relevant LaunchLayer section; Ask AI opens the same project's scoped Project Agent. This routing does not grant the AI extra permissions or silently apply a change.

Reconcile status

Reconcile status is for stale or uncertain workflow state. It asks existing provider-aware screenshot, cloud-build, and deployment status workflows to refresh their recorded evidence, then reloads the project. It does not create a new paid build, change signing or credentials, submit a binary, answer legal/privacy questions, or declare provider approval.

How to use it

1) Open the project and read the Command Center status. 2) Choose Check everything after meaningful setup changes. 3) Follow the single Do this next action. 4) Use Smart Fix Center only for the remaining items. 5) Use Reconcile status when an external job finished but LaunchLayer still looks stale. 6) Re-run Check everything before a build, upload, or review submission.

Audit history

Manual preflight checks and status reconciliations create project timeline events with the readiness phase and issue counts so users can see that the project was checked without storing provider secrets in the timeline.

Safety boundary

The Command Center is orchestration and evidence, not an unrestricted automation engine. It never promises store approval. Identity mismatches fail closed, signing and credentials remain explicit, privacy/legal answers remain human-owned, and paid build starts, binary uploads, review submissions, and other high-impact provider mutations stay behind their existing guarded workflows.

What the wrapping service actually does

A wrapper places a web experience inside a native iOS/Android shell; it does not magically convert every web feature into a native one.

Hosted web wrapper

A supported live-URL path packages a native shell that loads the configured HTTPS web experience. This is useful when the product is primarily web-based and the live site is intentionally the runtime source.

Bundled web assets

When a project has buildable web source and a supported package path, web assets can be prepared for inclusion inside the native project. The exact behavior depends on the source/build path and generated configuration.

Capacitor layer

LaunchLayer uses Capacitor-oriented native project structure for supported wrapper workflows. Capacitor provides the bridge between JavaScript/web UI and native iOS/Android capabilities through plugins and platform code.

Native features

Capabilities such as push notifications, biometrics, camera access, deep links, in-app purchases, files, location, and social login require the correct plugins, platform configuration, permissions, external provider setup, app logic, and device testing. Selecting or generating a feature plan does not by itself finish those external or app-specific steps.

What stays web

Your web application's UI, backend, authentication model, APIs, and business logic remain your responsibility unless a specific LaunchLayer workflow explicitly changes or generates part of them.

What cannot be recovered

An uploaded IPA/APK/AAB is compiled output. LaunchLayer can inspect supported metadata and use supported deployment paths, but it does not reconstruct the original source code or safely bolt arbitrary new native features into a signed binary.

When a rebuild is required

Changes to bundle/package identity, native plugins, entitlements, permissions, signing, app icon embedded in the binary, native SDK configuration, or compiled code normally require a new native build. Store-listing-only changes may not require a binary rebuild.

Automation and AI — what is automatic and what is advisory

LaunchLayer combines deterministic release checks, provider integrations, generated guidance, and AI-assisted workflows; these are not interchangeable.

Deterministic automation

Release identity checks, stored project state, artifact validation, provider status reads, workflow dispatch, job history, readiness gates, and supported upload calls should rely on structured data and explicit rules. These operations should not depend on an AI model guessing.

AI-assisted guidance

AI can help explain errors, organize setup steps, interpret project context, draft store-facing text, suggest next actions, and turn technical evidence into plain-English guidance. AI output should be reviewed before it is treated as release truth.

Generated configuration

LaunchLayer can generate configuration examples, dependency lists, install commands, implementation notes, permission wording, checklists, and package files for supported workflows. Generated output still has to match the real application, provider accounts, and release target.

External automation

GitHub Actions, App Store Connect, Google Play, RevenueCat, Firebase, and similar services execute work under their own credentials, quotas, policies, and availability. LaunchLayer can orchestrate supported calls but does not control those providers.

Human approvals

Credential entry, account ownership, final app behavior, legal/privacy accuracy, pricing decisions, store declarations, review responses, staged rollout, and production release decisions remain human responsibilities unless a specific provider-supported action is explicitly available.

Failure behavior

A trustworthy automation should fail closed on identity, signing, source, or credential mismatches rather than silently substituting another app, icon, identifier, or protected release input. A retry should create traceable history rather than erase the prior attempt.

No hidden guarantee

Automation can reduce manual steps and detect known mistakes. It cannot guarantee compilation success for arbitrary source, provider uptime, App Store or Play approval, review timing, ranking, downloads, revenue, or defect-free behavior on every device.

Project Agent: project-scoped AI help and guarded fixes

Production

Each project has its own AI assistant that reads live LaunchLayer evidence, stays scoped to the authenticated user's project, and routes changes through guarded approval paths instead of silent AI writes.

Project isolation

The Project Agent conversation is created for one project and every user message carries that project ID plus a short-lived server-issued scope token as authoritative context. The token is bound to the authenticated user and exact project, and server-side access checks verify both before agent context or proposal data is returned. A different project ID or token typed into chat does not override the authoritative scope.

What it can answer

The agent can explain LaunchLayer, inspect the current project's safe project metadata, recent source inspection, build, deployment, QA, compliance, rejection, store-connection, native-feature, artifact, and release-autopilot evidence, then give project-specific next steps. It is instructed to distinguish verified project facts from suggestions.

Safe project updates

When a user explicitly asks for a local setting change, the agent can prepare a reviewable proposal only for project name, app name, app version, build number, GitHub branch, or target platforms. The proposal shows exact current and proposed values, expires automatically, and cannot apply itself. Applying it requires an explicit user approval in the Project Agent panel and a server re-check that the original values have not changed.

Guarded repair

LaunchLayer can also preview and, after explicit approval, execute the existing allowlisted stale local release-state reconciliation. The proposal and state fingerprints are revalidated immediately before execution and the underlying repair path preserves reversible state. Other failure categories remain guidance-only until they have their own bounded verified executor.

What it cannot change

The agent cannot directly change bundle IDs or Android package identity, signing material, provider credentials, store-review decisions, source code, arbitrary native code, binaries, provider-side records, or start paid builds or uploads. Those boundaries are deliberate because a language model should not receive unrestricted production mutation authority.

Usage safeguards

Server-side limits are independent of the UI: up to 40 agent messages per hour and 150 per day per user/project, 80 project-context reads per hour, 12 safe-setting proposals per hour, 6 approved safe-setting applications per day, 10 stale-state repair previews per hour, and 3 stale-state repair executions per day. Limits may be revised as LaunchLayer usage and plan enforcement evolve.

Auditability

Safe setting applications, repair previews/executions, dismissals, and related outcomes are recorded with the authenticated user and project. A retry or new proposal does not silently erase prior action history.

Important limitation

Project scoping and server checks substantially reduce cross-project drift, but AI output can still be mistaken. The agent's factual project answers are instructed to consult live evidence, and high-risk or unsupported changes remain blocked rather than being entrusted to model judgment.

Integration guide: how LaunchLayer connects to external services

A truthful map of what LaunchLayer reads, what it can write, what credentials are required, what still happens in the provider, and which integrations are production versus planned.

Integration rule

LaunchLayer does not treat every integration as equally automated. Each capability has its own account requirements, credentials, read/write scope, confirmation rules, verification steps, and provider-controlled limits. When provider state conflicts with LaunchLayer state, the provider is authoritative.

GitHub

Production wrapper/cloud-build workflows use the connected GitHub account and GitHub Actions for supported build and deployment jobs. LaunchLayer can create or use the configured private build repository and record workflow/run evidence. GitHub permissions, repository access, Actions availability, quotas, secrets, and runner behavior remain controlled by GitHub. Arbitrary GitHub Source Build V2 compilation is still planned; current V2 behavior is source inspection plus a deterministic readiness contract, not unrestricted customer-code execution.

Apple Developer and App Store Connect

Production Apple workflows support exact-app binding, credential validation, signed-IPA deployment, supported listing/localization/review-information updates, age rating, accessibility, TestFlight configuration, export compliance, availability, app settings, pricing, Apple IAP/subscription metadata, review submission, and release controls where the provider API supports them. Mutating operations require the configured App Store Connect credentials, exact app/version identity, explicit confirmation where applicable, and provider read-back or state verification. Apple controls processing, policy review, approval, and final provider state.

Google Play

Production Google workflows support matching Android artifact deployment plus supported listing text, contact details, supported images, Data Safety, tester groups, monetization catalog data, release tracks, and staged-rollout controls. These require the exact package/application binding and configured Google service-account access. LaunchLayer validates and commits supported provider edits, but Google controls processing, Play Console-only declarations, policy review, and final publication state.

RevenueCat and purchases

LaunchLayer currently provides monetization setup guidance, store-product synchronization/audit evidence, client-safe RevenueCat configuration checks, and a Purchase & Subscription Test Lab that records real Apple Sandbox/TestFlight or Google Play test outcomes. The separate hosted RevenueCat IAP manager for automatically managing RevenueCat products, entitlements, offerings, packages, webhooks, and synchronized customer state remains planned. A passing purchase must come from the real store test environment; LaunchLayer does not simulate one.

Push, Firebase, APNs and analytics

Native setup plans can describe dependencies, configuration, permissions, provider setup, and device tests. The managed Hosted Push Center using APNs/FCM and the provider-adapter Release Analytics capability are still planned. Do not interpret generated setup guidance as a production push backend or live crash/analytics connection. Post-Launch Health currently records dated evidence snapshots rather than claiming live telemetry.

Base44 and other app builders

LaunchLayer can accept supported Base44, React, Vite, and other web-app starting points through a live URL, GitHub repository, or source ZIP. A builder remains the owner of its own application runtime, backend, auth, database, and source. LaunchLayer wraps or prepares the release path; it does not automatically migrate or assume ownership of another platform's backend.

AI Project Agent

The Project Agent is an internal LaunchLayer integration layer rather than a third-party provider connection. It can read only the authenticated user's scoped project evidence through a server-side context broker and can prepare only allowlisted local-setting proposals. It cannot directly mutate credentials, signing, binaries, provider records, store review actions, or paid builds. Safe setting changes and the allowlisted stale local release-state repair require explicit approval and are revalidated before execution.

Credential handling

Credentials should be entered only through the designated secure LaunchLayer/provider fields, never pasted into the Project Agent chat, public support text, screenshots, or source control. LaunchLayer should expose non-secret readiness metadata where possible and fail closed when identity, signing, permission, or credential evidence does not match the intended app.

How to verify an integration

1) confirm the exact LaunchLayer project and app identity; 2) confirm the intended external account/team/application; 3) validate the credential or OAuth connection; 4) run the narrow supported read/preflight operation; 5) preview any mutation; 6) explicitly approve it; 7) read back provider state or durable LaunchLayer evidence; 8) keep the attempt in history rather than overwriting it; 9) test the released behavior on the real target environment when required.

Production versus planned

LaunchLayer marks capabilities independently. Hosted-wrapper builds, signed-binary deployment, Apple/Google publishing workflows, monetization sync audit, purchase test evidence, release monitoring, and the guarded Project Agent are implemented production capabilities as described in the app. Arbitrary Source Build V2 compilation, Hosted Push Center, the full hosted RevenueCat IAP manager, and live provider-adapter release analytics remain planned unless the capability registry is updated after verified release.

Choose the correct build path

LaunchLayer supports different starting materials, and choosing the wrong path is one of the easiest ways to create release confusion.

Live HTTPS URL

Use when you intentionally want a hosted web wrapper. LaunchLayer prepares a native shell around the configured web experience and the release still needs normal signing, testing, store metadata, and review.

GitHub repository

Use when you control source and need source inspection or a supported build-preparation workflow. Legacy hosted-wrapper cloud builds use LaunchLayer-generated repositories; Source Build V2 inspection for arbitrary GitHub source is a separate beta readiness path and does not yet mean arbitrary-source V2 compilation is enabled.

Source ZIP

Use for controlled source inspection when repository access is not the input. ZIP inspection validates archive safety and project-root/build evidence. Source Build V2 arbitrary-source compilation remains disabled until the isolated runner path is released.

Existing IPA

Use this path when Base44 or another trusted source already gives you the signed IPA you intend to submit. Go directly to Direct Deployment; do not run Cloud Build just to submit that IPA. LaunchLayer validates the existing binary and its exact Bundle ID before upload. App Store Connect API credentials use the .p8 key/Key ID/Issuer ID/Team ID; a .p12 Distribution certificate and its export password are build-signing inputs and are not required merely to upload an already-signed IPA. Do not choose this path expecting LaunchLayer to recover editable iOS source.

Existing APK or AAB

Use for Android binary inspection and supported Play-oriented deployment workflows when the package identity and signing/release requirements are correct.

Existing store app

Connect the corresponding provider when the app already exists in App Store Connect or Google Play. LaunchLayer can compare provider state with local project/build state and help continue the release rather than creating a second identity.

How to decide

If you need to change compiled native behavior, use source plus a rebuild path. If the binary is already correct and you only need inspection, store metadata, or upload, use the existing-build path. If you are unsure, start with the material that is actually authoritative rather than converting it unnecessarily.

Build, upload, TestFlight/Play testing, review, and release

Deployment is a sequence of separate provider states; uploading a build is not the same as publishing it.

Build

A native build compiles the configured project into an iOS or Android artifact. iOS distribution requires Apple signing; Android release output requires the intended package/signing configuration.

Preflight

Before upload, LaunchLayer can compare artifact metadata, project identifiers, configured store application identity, signing/readiness data, and version/build information. Mismatches should be resolved before provider upload.

Upload

A supported direct-deployment job transfers the existing artifact to the provider using configured credentials. Upload success means the provider accepted the transfer request or artifact; it does not mean review or publication is complete.

Provider processing

Apple and Google process uploaded binaries before they become selectable for testing or release. Processing time and provider-side failures are outside LaunchLayer's control.

Testing

Apple TestFlight and Google testing tracks are provider-managed distribution stages. Test the actual store-distributed build, including login, purchases, notifications, deep links, permissions, and any native bridges relevant to the app.

Store listing and declarations

Screenshots, descriptions, privacy disclosures, age/content answers, export/compliance information, data-safety/privacy details, pricing, territories, and review notes must accurately describe the released app. LaunchLayer can assist with preparation but the account owner is responsible for accuracy.

Review and publication

Apple or Google decides whether an app satisfies its current policies. After approval, release may still be manual, scheduled, phased, staged, or otherwise controlled by provider settings. LaunchLayer cannot promise approval or an exact review timeline.

Credentials, signing, secrets, and account ownership

The safest release setup keeps ownership with the customer's developer accounts and separates public client configuration from private signing/server secrets.

Apple

Use the intended Apple Developer/App Store Connect team, bundle identifier, certificates/profiles or supported signing method, and App Store Connect API credentials with only the permissions required for the operation. Expired, mismatched, or wrong-team signing material will break distribution.

Google

Use the intended Play Console application/package and service credentials with the minimum permissions needed. Package identity and version codes must match the release target.

GitHub

Repository access and Actions execution are governed by the connected GitHub account, repository permissions, secrets, branch state, Actions quotas, and provider availability.

RevenueCat

Client applications use RevenueCat public platform SDK keys. Secret API keys and webhook secrets belong in trusted server-side environments, not bundled into the mobile client.

Other providers

Firebase/APNs, social login, maps, analytics, crash reporting, payment providers, and similar integrations each have their own client IDs, server secrets, certificates, redirect URIs, entitlements, or console configuration. A LaunchLayer checklist does not replace those provider requirements.

Secret handling

Do not paste private keys into public documentation, commit them to source repositories, or embed server credentials in browser/native client code. Rotate credentials if exposure is suspected.

Ownership model

Developer accounts, store listings, signing identity, production domains, provider projects, and customer data should remain under the appropriate owner-controlled accounts. LaunchLayer is a release workspace and orchestration layer, not the legal owner of those external accounts.

How updates work after the first launch

A released app becomes the starting point for the next release; updates still require identity continuity and, when native inputs change, a new build.

Same app identity

Keep the same Apple bundle identifier and Android package name when updating the same store application. Changing those identifiers generally means a different app identity rather than a normal update.

Versioning

Each store has version/build rules. Increment the appropriate marketing version and/or build number or version code as required by the provider and your current release state.

Web-only changes

For a deliberately hosted live-URL wrapper, some web content can change without a new native binary because the shell loads the hosted app. That does not bypass store rules for changes that materially alter regulated/native behavior, nor does it update embedded native code or metadata.

Native changes

Changes to native plugins, entitlements, permissions, embedded SDKs, signing, compiled assets, native configuration, or native application code require a new build and another release cycle.

Store metadata changes

Some listing fields and screenshots can be changed independently of the binary when the provider allows it; other metadata is version-scoped or review-scoped. Provider state is authoritative.

Existing-build replacement

When replacing a build, upload a newly built artifact with valid identity and versioning rather than trying to mutate the old uploaded binary.

Release history

Keep build, deployment, and approval history intact so you can tell which source/configuration produced which artifact and which artifact reached which provider state.

What LaunchLayer does not promise

A truthful release guide includes the boundaries: some steps are automated, some are generated assistance, and some always remain external.

No automatic source recovery

Compiled IPA/APK/AAB files are not treated as editable source projects.

No universal one-click compilation

Legacy hosted-wrapper cloud builds are supported through their configured workflow. Source Build V2 inspection exists for arbitrary GitHub/ZIP source, but arbitrary-source V2 compilation is still disabled until the isolated runner/artifact boundary is released.

No automatic native backend

Selecting push, purchases, auth, deep links, wallets, widgets, live activities, or other capabilities does not silently create every external service, server endpoint, provider account, entitlement, webhook, or app-specific code path needed in production.

No approval guarantee

LaunchLayer can prepare, validate, upload, explain, and monitor supported release steps. Apple and Google control processing, policy review, approval, rejection, and publication.

No provider guarantee

GitHub, Apple, Google, RevenueCat, Firebase, and other providers can change APIs, permissions, policies, quotas, processing behavior, and availability.

No replacement for testing

Successful compilation or upload is not equivalent to a working production app. Real-device and store-distributed testing are required for the features your app uses.

No substitute for legal accuracy

Privacy, terms, data-safety disclosures, regulated-content declarations, export compliance, and other legal/compliance answers must match the app's actual behavior and organization obligations.

How to troubleshoot a release without guessing

Use evidence from the exact project, build, provider, and attempt before changing code or credentials.

Start with identity

Confirm app name, bundle/package ID, source commit or archive, version/build number, signing team/key, connected store application, and selected platform. Many release problems are identity mismatches rather than code defects.

Read the failing stage

Separate inspection, source checkout, dependency install, web build, native sync, native compilation, signing, validation, upload, provider processing, and review. Fix the stage that actually failed rather than restarting the entire release blindly.

Use provider evidence

For GitHub failures, inspect the specific Actions run. For Apple or Google failures, use the provider response and processing state. For RevenueCat or other integrations, verify project/app/product identifiers and environment before changing code.

Preserve attempts

Do not overwrite the historical record of a failed upload or build. A new attempt should be linked to the previous one so the change and result are auditable.

Retry only after a change or transient failure

If the failure is deterministic—wrong ID, expired profile, missing secret, incompatible dependency—repeating the same inputs will usually repeat the failure. Correct the cause first.

Escalate with a reproducible package

When support is needed, include the project, platform, source identity, version/build, exact failing stage, provider/job ID, error text, and what changed since the last known-good release. Do not include private keys or secrets in screenshots or tickets.

Getting started

What LaunchLayer is — and is not

Production

A guided app release workspace for source preparation, signed-build inspection, QA, approvals, store setup, configured builds, and deployment.

What you need

Choose the starting material you actually have: a live HTTPS URL, GitHub repository, source ZIP, signed IPA/APK/AAB, or an existing store application.

What LaunchLayer does

LaunchLayer organizes preparation, inspection, QA, approvals, store assets, compliance information, configured cloud builds, exact identity checks, and supported Apple or Google uploads in one workspace. The workspace uses one human-facing release status language, one guided release journey, one primary next action, evidence explanations, and freshness cues while preserving detailed provider states underneath.

What you still need to do

Maintain developer accounts, provide valid credentials, review generated material, device-test native behavior, and make final store decisions. Upload does not guarantee publication or approval.

Common problems

Choosing a compiled binary when you need source changes, expecting a generated configuration to be a tested backend, or connecting a store app whose identifier does not exactly match the build.

Choose a starting point

Production

Use source when rebuilding; use a signed binary for inspection and direct upload; use a store connection to continue an existing listing.

Live URL

Best for a hosted wrapper around an HTTPS web app.

GitHub or ZIP

Best for source inspection and guided build preparation. Compatibility and build requirements still matter.

IPA, APK, or AAB

These are compiled binaries. LaunchLayer can inspect and upload supported signed builds, but cannot recover or substantially change their original source.

Existing store app

Connect App Store Connect or Google Play to inspect listing state, fill gaps, and match a build.

Project templates

Production

Save reusable store and build settings without copying names, source files, URLs, or credentials.

What you need

A configuration you expect to reuse.

What LaunchLayer does

Stores safe defaults such as platform, source type, branch, identifiers, version, and build number.

What you still need to do

Give each project its own name and provide its source, files, and credentials.

Common problems

Treating a template as a cloned project or expecting it to copy protected credentials.

Live URL projects

Hosted wrappers and HTTPS

Production

A hosted wrapper loads your live HTTPS application inside the mobile shell.

What you need

A stable public HTTPS URL and mobile-responsive application.

What LaunchLayer does

Generates hosted-wrapper configuration and guides external-link, cookie, session, upload, download, safe-area, and navigation setup.

What you still need to do

Keep the web app online, test authentication and protected routes on devices, and decide how offline states behave.

Common problems

HTTP URLs, blocked embedded sessions, third-party cookies, file pickers or downloads that behave differently on mobile, and external links opening in the wrong context.

GitHub and ZIP source

GitHub source inspection

Connect a repository and branch for source inspection and guided build preparation.

What you need

Repository access, the correct branch, build commands, and required environment variables.

What LaunchLayer does

Uses the connected GitHub workflow for supported repository and cloud-build operations and prepares wrapper configuration.

What you still need to do

Confirm framework detection, supply secrets, review build commands, and fix incompatible source or dependency failures.

Common problems

Wrong branch, private-repository permission, missing environment variables, unsupported framework output, or a build that does not produce the configured web directory.

Source ZIP requirements

A ZIP should contain a safe, recognizable project root with source and dependency manifests.

What you need

A ZIP containing the project—not a compiled IPA/APK/AAB—and its package manifest, source, and configuration.

What LaunchLayer does

Stores the source archive and guides project setup; supported inspection can identify expected project files.

What you still need to do

Confirm the correct root, dependencies, framework, build output, and environment configuration.

Common problems

Nested archives, missing package files, malformed or unsafe paths, uploaded build output without source, and dependencies that cannot install.

Existing signed builds

Existing signed IPA

Production

An IPA is a compiled, signed iOS application. Its embedded bundle ID and native code cannot be rewritten by LaunchLayer.

What you need

A valid signed IPA, matching App Store Connect application, Apple credentials, and an acceptable version/build number.

What LaunchLayer does

Inspects embedded identity and version, enforces exact bundle-ID matching, runs deployment preflight, uploads through the configured workflow, and monitors Apple processing.

What you still need to do

Rebuild from source for native-feature or embedded-icon changes, complete TestFlight testing, listing details, review submission, and Apple requirements.

Common problems

Invalid IPA, bundle-ID mismatch, expired signing assets, duplicate build number, App Store app mismatch, or Apple processing delays.

Existing APK and AAB

Production

APK is commonly installable; AAB is the Play publishing bundle. Both carry an immutable package name and version identity.

What you need

A valid signed APK or AAB, matching Google Play application and service-account access.

What LaunchLayer does

Inspects signature and manifest metadata, enforces package-name matching, preserves track mapping, validates version information, uploads, and monitors Google processing.

What you still need to do

Use an increasing version code, choose the intended Play track, complete console declarations, and manage rollout or publication.

Common problems

Unsigned or invalid artifacts, wrong package name, duplicate version code, insufficient Play permissions, wrong track, or processing delays.

Cloud Build

Legacy hosted-wrapper cloud builds

Production

GitHub Actions compiles LaunchLayer’s generated Capacitor wrapper; it does not compile inspected GitHub or ZIP source.

What you need

A connected GitHub account, compatible project inputs, available Actions minutes, and platform signing credentials for release artifacts.

What LaunchLayer does

Creates the generated repository when a build starts, dispatches the configured Android or iOS workflow, shows logs and status, and exposes available artifacts.

What you still need to do

Provide environment variables, add Apple signing for IPA builds, review generated configuration, download artifacts before expiration, and device-test them.

Common problems

Repository not appearing before Build is pressed, failed dependency installation, missing output directory, invalid signing material, exhausted Actions usage, or expired artifacts.

Direct deployment

Preflight, upload, and processing

Production

Direct deployment uploads an existing configured binary; it does not rebuild it or guarantee store publication.

What you need

A signed IPA/APK/AAB, exact identifier match, valid store credentials, a matching store application, and acceptable version identity.

What LaunchLayer does

Validates preflight, blocks mismatches and invalid signatures, prevents accidental duplicate active uploads, preserves job history, supports actionable retry or result recovery, and monitors processing.

What you still need to do

Resolve store-side requirements, complete declarations and review, manage testing tracks or rollout, and wait for store processing.

Common problems

Invalid credentials, wrong bundle ID or package name, duplicate version/build number, expired profile, failed runner, missing result artifact, or delayed processing. Retry creates a new attempt; it does not overwrite history.

Native capabilities

Generated setup plans versus implementation

Generated

Marketplace selections generate native setup and implementation plans; they do not silently create a production backend or complete device testing.

What you need

Source code, a rebuild path, plugin and platform accounts, and physical devices where required.

What LaunchLayer does

Generates dependencies, install commands, configuration examples, permission copy, compliance notes, and test checklists for Capacitor basics, push, camera/photos, location, biometrics, social login, IAP/subscriptions, deep links, files/sharing, offline support, OTA planning, and Tap to Pay guidance. Native Essentials Quickstart surfaces push notifications, biometric login, and deep links first because they are common production needs.

What you still need to do

Implement application logic, configure APNs/FCM or other external consoles, provide credentials and backend services, rebuild, sign, and verify on devices.

Common problems

Treating generated snippets as completed implementation, skipping privacy disclosures, using capabilities unsupported by a device, or trying to add native behavior to an already signed binary without source.

Store preparation

Metadata, assets, privacy, and declarations

Production

Prepare listing text, screenshots, icons, URLs, privacy information, and console-specific declarations.

What you need

Accurate app behavior, support and privacy URLs, approved assets, category and age-rating decisions, and account-deletion details where required.

What LaunchLayer does

Organizes metadata, screenshots, icons, review notes, Apple privacy preparation, Google Data Safety preparation, missing-item status, screenshot-readiness findings, and project-relevant Policy Watch reminders from a dated official-policy baseline.

What you still need to do

Verify every claim, answer console questions truthfully, approve assets, and complete manual console fields that cannot be safely automated.

Common problems

Screenshots for the wrong device family, icon/build mismatch, inaccurate data declarations, missing deletion URL, or metadata that overstates app behavior.

Apple Developer and Google Play account setup

Create the publisher accounts, ownership, agreements, and access LaunchLayer needs before store-side work can succeed.

Apple

Use the intended legal owner or organization. Complete Apple Developer enrollment, App Store Connect access, agreements, tax/banking where applicable, and create or confirm the exact App ID/bundle ID. App Store Connect API access needs the correct issuer, key, role, Team ID, and app access.

Google

Create the intended Play Console developer account, complete identity and organization verification, payments profile where applicable, app record, and required developer-account declarations. Service-account access must be granted inside Play Console to the exact application and actions LaunchLayer will perform.

Before connecting LaunchLayer

Know who owns each account, which email/account should remain authoritative, the exact bundle/package identifier, whether the app already exists, and whether another vendor controls signing or release credentials.

Common problems

Wrong account ownership, pending agreements, insufficient API/service-account permissions, app access not granted, duplicate app records, mismatched identifiers, or credentials created in the wrong organization.

TestFlight, Play testing tracks, review, and rollout

Use store testing to verify the same release candidate you intend to submit or promote.

Apple

Upload the exact release build, wait for processing, configure TestFlight information and tester access, verify purchases with sandbox/TestFlight accounts when used, then select the tested build for App Review. External testing may require Apple beta review.

Google

Use internal or closed testing before production when appropriate. Verify the exact version code, tester groups, app-access instructions, Data Safety/content declarations, purchase products, and device behavior before promoting the release.

What to test

Authentication, account creation/deletion, navigation, safe areas, permissions, deep links, uploads/downloads, notifications if used, purchases/restores, subscription state, offline/network failure, support/privacy links, and any reviewer credentials.

Common problems

Testing a different binary than the one submitted, expired tester access, missing reviewer credentials, products unavailable to test accounts, incomplete declarations, wrong track, or promoting an unverified version code.

Payments and subscriptions

In-app purchases and subscriptions: choose the architecture first

Production

Start with what the user is buying and where purchase occurs; do not assume StoreKit, Play Billing, or external checkout without confirming the product architecture and storefront scope.

Questions LaunchLayer should resolve

Is the item digital app functionality/content, a physical good/service, or something consumed outside the app? Is it one-time or recurring? Which stores and storefronts are targeted? Should purchase happen inside the app, on the web, or both? Is RevenueCat being used? Which system is authoritative for entitlement state?

Apple path

For Apple IAP/subscriptions, create the exact product IDs in App Store Connect, complete pricing and review metadata, add subscription groups where required, configure restore behavior and subscription disclosures, then map the same IDs into the app/RevenueCat. Test with Apple sandbox/TestFlight accounts before review.

Google path

For Google Play monetization, create one-time products or subscriptions, base plans/offers and regional pricing, activate the intended purchase options/base plans, map exact IDs into the app/RevenueCat, and test with licensed/test users on an eligible Play build.

External checkout

Treat external checkout as an explicit architecture choice, not an automatic workaround. Validate current store rules for the targeted storefronts and the exact product type before changing the app. Preserve the user's confirmed architecture unless they explicitly change it.

Verification

Product IDs must match across code, LaunchLayer, RevenueCat, App Store Connect, and Play Console. Use LaunchLayer’s Purchase & Subscription Test Lab to record real sandbox/TestFlight/Play outcomes for catalog loading, purchase, entitlement unlock, restore, reinstall recovery, failure handling, renewal/cancellation, billing retry/grace, and tier changes where applicable. A recorded pass is user evidence, not a provider guarantee.

Common problems

Product not approved/active, ID mismatch, wrong RevenueCat public key or offering, missing entitlement mapping, subscription base plan inactive, sandbox account issue, review metadata incomplete, restore missing, or a billing architecture that does not match actual store policy.

RevenueCat setup and troubleshooting

RevenueCat sits between your app and store products; the stores remain the source for product availability and transaction processing.

Setup order

Create products in Apple/Google first, then import/map them in RevenueCat, create the entitlement, offering and packages, configure the platform public SDK keys, and connect the app's purchase/restore/customer-info flow.

LaunchLayer configuration

Use the public iOS/Android SDK keys, entitlement ID, offering ID and package identifiers intended for the release. Secret RevenueCat API keys or webhook secrets must not be shipped in the client.

Testing

Test on real store-distributed or sandbox-capable builds with valid tester accounts. Confirm offering load, package selection, purchase, restore, entitlement visibility, cancellation/expiration behavior, and environment separation.

Common failures

Store product is not ready, bundle/package ID is linked to the wrong RevenueCat app, product ID mismatch, offering has no package, wrong public SDK key, cached entitlement state, or testing outside a store-supported purchase environment.

QA and approval

QA scans, client approvals, and audit records

Production

Release-readiness scans and approval portals create evidence and gates; they cannot guarantee a defect-free app or store approval.

What you need

A reachable test target, realistic test context, and reviewers authorized to approve the release.

What LaunchLayer does

Runs supported automated checks, ranks issues, records comments and decisions, preserves audit history, derives Release Intelligence and evidence gaps, compares recent build/package/artifact evidence through Release Diff, and can retain dated post-launch health snapshots from Apple, Google Play, or another provider report without claiming live telemetry.

What you still need to do

Test devices, payments, native integrations, accessibility, edge cases, and store policy details that automation cannot prove.

Common problems

Scanning the wrong URL, protected routes without access, assuming a high score guarantees approval, or requesting sign-off before blockers are resolved.

Troubleshooting

Build and deployment troubleshooting

Production

Use the failing stage to decide whether to retry, correct configuration, or produce a new binary.

Credentials

Revalidate account access, issuer/key/team details, service-account permissions, and matching application access.

Identity and signing

Bundle ID and package name must match exactly. Invalid signatures, expired profiles, and changed identifiers require correction or a source rebuild.

Versions

Apple build numbers and Google version codes must satisfy store rules; Google version codes must increase.

Builds and artifacts

Open GitHub logs for dependency, command, signing, or output failures. Missing or expired artifacts may require a new build.

Processing and retry

Store processing can take time. Refresh status first; retry only a failed upload, and start a new upload when the binary itself must change.

Security and ownership

Credentials, access, ownership, and retention

Use scoped accounts and project permissions, and understand where generated repositories and project records live.

What you need

Only the access required for your workflow and an ownership plan for GitHub and store accounts.

What LaunchLayer does

Creates generated repositories in the connected GitHub account, uses protected credential flows, stores GitHub build values as encrypted repository secrets where configured, and applies project/team access controls.

What you still need to do

Rotate revoked credentials, manage team access, retain required artifacts and audit records, and review account ownership before staff changes.

Common problems

Connecting the wrong account, over-broad permissions, deleting a repository that owns build history, or assuming project deletion also removes data held by Apple, Google, or GitHub.

Source Build V2

GitHub Source Build V2 inspection

Beta

Beta inspection verifies repository access, branch, exact commit, project root, framework, package manager, build script, output, and environment-variable references before any runner dispatch; compilation is planned and disabled.

What this does

Creates a stable source snapshot and controlled build configuration for the future isolated V2 runner.

What you need

A readable repository, branch, compatible static web build, and connected GitHub account.

What LaunchLayer automates

Permission check, default-branch and commit resolution, file evidence, framework hints, lockfile priority, and configuration proposal.

What remains external

Secret values, GitHub Actions capacity, platform signing, and device testing.

Exact setup steps

Connect GitHub, open Cloud Build, inspect source, choose a project root when prompted, review commands and output, then confirm configuration.

How to verify it

Confirm the displayed owner, repository, branch, commit SHA, framework evidence, and output directory match the intended release source.

Common failures

Wrong account, inaccessible private repository, wrong branch, truncated tree, missing build script, or server-required framework.

Security considerations

LaunchLayer reads source metadata through the current app user's connector and never executes repository code in the application backend.

Related articles

Repository permissions; framework detection and monorepos; Cloud Build stages.

Repository permission problems

A typed GitHub URL is not sufficient; the connected account must be able to resolve and read the repository and branch.

What this does

Explains authorization failures before source inspection.

What you need

The correct GitHub account and repository access.

What LaunchLayer automates

Repository lookup and permission verification.

What remains external

Organization SSO authorization and repository invitation acceptance.

Exact setup steps

Reconnect the intended account, authorize organization access if required, verify the branch, and inspect again.

How to verify it

The inspection shows repository permission verified and an exact commit SHA.

Common failures

Wrong account, private-repository denial, organization SSO restrictions, renamed repository, or missing branch.

Security considerations

Use least-privilege repository access and disconnect accounts no longer required.

Related articles

Real GitHub source builds; security and ownership.

Framework detection, monorepos, environment variables, build commands, and output

Compatibility depends on the selected project root producing static web output that Capacitor can bundle.

What this does

Shows evidence for Vite, CRA, Angular, Vue, static SvelteKit, Next static export, and plain HTML while identifying server-required applications.

What you need

A build script, supported Node version, dependency manifest, and correct output directory.

What LaunchLayer automates

Lockfile priority, safe command selection, framework hints, candidate-root discovery, and environment-variable references found in inspected files.

What remains external

Secret values, framework-specific corrections, and choosing among multiple monorepo roots.

Exact setup steps

Select the project root, package manager, approved install/build commands, Node 18/20/22, output directory, and required variable names.

How to verify it

Run the same build at the exact commit and confirm the output directory exists and is nonempty.

Common failures

Missing lockfile, missing build script, wrong root, incorrect dist/build/out path, SSR dependency, or missing environment value.

Security considerations

Arbitrary shell strings are rejected; secret values belong in protected GitHub environments or secrets.

Related articles

GitHub source builds; ZIP source ingestion; Cloud Build stages.

Safe ZIP ingestion and project-root selection

Beta

Beta ZIP inspection validates integrity and limits before reading source metadata; it does not execute archive contents.

What this does

Hashes the archive, rejects unsafe paths, symlinks, nested archives, malformed or encrypted ZIPs, and discovers candidate project roots.

What you need

A source ZIP under 50 MB compressed, 250 MB expanded, and 10,000 files.

What LaunchLayer automates

SHA-256, CRC verification, path normalization, expanded-size accounting, root discovery, and shared framework analysis.

What remains external

Choosing among multiple roots, supplying environment values, and later isolated compilation.

Exact setup steps

Upload the source ZIP, inspect it, choose a candidate root when prompted, re-inspect, and confirm controlled configuration.

How to verify it

Review the archive hash, file count, expanded size, selected root, and framework evidence.

Common failures

Traversal paths, nested archives, archive bombs, encryption, malformed JSON, multiple roots, or missing source manifests.

Security considerations

Archive contents never execute in LaunchLayer; future compilation must use an isolated runner.

Related articles

Framework detection; security and ownership.

Builds, signing, and artifacts

Android debug APK

Production

A debug APK supports quick compatibility and device testing; it is not intended for Play production publishing.

What this does

Compiles a test APK through the configured legacy GitHub workflow.

What you need

A compatible wrapper configuration and available GitHub Actions capacity.

What LaunchLayer automates

Generated workflow, Capacitor Android setup, debug compile, status, and artifact link.

What remains external

Device installation and testing.

Exact setup steps

Connect GitHub, start Build Android APK, monitor the run, download, and test on compatible devices.

How to verify it

Install on a test device and confirm identity, navigation, permissions, and network behavior.

Common failures

Dependency installation, Gradle setup, missing output, or expired artifact.

Security considerations

Do not treat debug signing as production signing.

Related articles

Cloud Build stages; Android signed AAB.

Android signed AAB and keystores

Planned

Planned: release AAB generation requires protected keystore material and post-build artifact validation.

What this does

Will create a Play-ready release bundle without renaming package identity.

What you need

Keystore, alias, passwords, increasing version code, and matching Play package.

What LaunchLayer automates

Planned signing configuration, bundle task, checksum, package/version inspection, and fingerprint recording.

What remains external

Keystore ownership, Play account, track selection, rollout, and publication.

Exact setup steps

Not released; continue using an existing signed AAB through direct deployment.

How to verify it

A future release must prove signature, package, version name/code, checksum, and tenant-safe download.

Common failures

Wrong alias/password, package mismatch, duplicate version code, or missing artifact.

Security considerations

Keystore bytes and passwords must remain encrypted secrets and never enter logs or repositories.

Related articles

Existing APK/AAB; Certificate Center.

Apple certificates, provisioning profiles, and Android keystores

Beta

Certificate Center displays non-secret readiness metadata and expiration warnings without duplicating secret material.

What this does

Shows fingerprints, names, Team ID, profile UUID, allowed identity, distribution method, alias, package link, validation, and last use when inspected.

What you need

Credentials added through existing protected project flows.

What LaunchLayer automates

Metadata display plus Signing Renewal Intelligence with 90-day planning, 30-day preparation, and 7-day urgent warning bands.

What remains external

Credential issuance, renewal, revocation, and account ownership.

Exact setup steps

Add credentials in the project, validate them, then open Certificate Center.

How to verify it

Compare non-secret metadata with Apple Developer, App Store Connect, or the Android keystore certificate.

Common failures

Expired certificate/profile, wrong Team ID, wildcard or mismatched profile, wrong alias, or missing metadata extraction.

Security considerations

Private keys, p8/p12/profile content, passwords, service-account keys, and keystore bytes are never rendered.

Related articles

Cloud Build; direct deployment; security and ownership.

Cloud Build stages and artifact expiration

Production

V2 jobs use specific stages and preserve source, configuration, logs, errors, artifacts, and linked retries.

What this does

Distinguishes inspection, checkout, install, web build, output verification, Capacitor sync, native compile, signing, validation, upload, completion, and failure.

What you need

A confirmed configuration and future enabled V2 dispatch.

What LaunchLayer automates

Source Build Readiness Contract generation from the exact source identity, controlled commands, output directory, target platforms, environment-variable names, and signing metadata. Actual arbitrary-source dispatch remains disabled until the isolated runner and artifact-validation boundary is released.

What remains external

Runner capacity, source fixes, signing ownership, and timely artifact download.

Exact setup steps

V2 dispatch is not released in Phase 1; legacy Cloud Build remains unchanged.

How to verify it

Every future job must record exact commit/archive hash and configuration, and retry must create a new linked record.

Common failures

Dependency error, missing output, signing failure, missing artifact, or expiration.

Security considerations

Artifacts require authorized or signed downloads and must remain tenant-isolated.

Related articles

Real GitHub source builds; Android debug APK; Certificate Center.

Planned platform modules

Push Center, APNs, Firebase, and device tokens

Planned

Planned: hosted push remains unavailable until physical-device delivery, authenticated registration, batching, idempotency, invalid-token handling, and tenant isolation are verified.

What this does

Will manage provider credentials, devices, audiences, campaigns, messages, deliveries, and templates.

What you need

Source rebuild, APNs and FCM setup, provider credentials, and physical iOS/Android devices.

What LaunchLayer automates

Planned registration contract, audience resolution, queued batches, provider results, scheduled and event sends, and invalid-token disablement.

What remains external

Apple/Firebase accounts, user permission, client integration, and device verification.

Exact setup steps

Not released; use the generated native push setup plan only.

How to verify it

Permission, initial/refresh registration, logout, individual/segment/scheduled sends, deep links, invalidation, and duplicate prevention must pass.

Common failures

Sandbox/production mix, stale token, denied permission, wrong APNs topic, Firebase mismatch, or duplicate retry.

Security considerations

Tokens and credentials must be encrypted/redacted; sends require rate limits, payload caps, validated deep links, and idempotency.

Related articles

Native features; security and ownership.

RevenueCat IAP: products, entitlements, offerings, paywalls, and webhooks

Planned

Planned: IAP management will follow RevenueCat's product-to-entitlement-to-offering model and will not unlock access from a client callback alone.

What this does

Will import products, map entitlements, configure offerings/packages/paywalls, generate SDK flows, and synchronize customer state.

What you need

RevenueCat, Apple, and Google products plus sandbox accounts.

What LaunchLayer automates

Planned configuration import, SDK output, purchase/restore examples, webhook deduplication, and entitlement synchronization.

What remains external

Store product approval, sandbox purchase, app integration, and pricing decisions.

Exact setup steps

Not released; use the generated IAP setup plan only.

How to verify it

Offering load, sandbox purchase, restore, entitlement return, cancellation, signature/auth check, dedupe, and environment separation must pass.

Common failures

Product ID mismatch, product not ready, missing offering, wrong public key, or duplicate webhook.

Security considerations

Preserve raw webhook body, authenticate requests, reject stale/replayed events, return quickly, and process idempotently.

Related articles

Native features; security and ownership.

Analytics providers and crash reporting

Planned

Planned provider adapters will display only metrics returned by connected Firebase or Sentry services.

What this does

Will normalize release health, adoption, crash-free usage, crash groups, affected builds, and regressions.

What you need

A supported provider connection and correctly instrumented app.

What LaunchLayer automates

Planned connection validation and normalized read-only dashboards.

What remains external

SDK implementation, privacy declarations, symbol uploads, and provider retention.

Exact setup steps

Not released; use generated analytics/crash setup plans.

How to verify it

Send a test event and test crash, then compare returned provider data without fabricated fallback values.

Common failures

Wrong project, missing symbols, blocked network, privacy mismatch, or no data.

Security considerations

Do not ingest unnecessary PII or display metrics when no provider is connected.

Related articles

Native features; privacy preparation.

Project-level roles and sensitive-action confirmation

Planned

Planned roles require server-side permission enforcement; hiding buttons is not authorization.

What this does

Will separate owner, administrator, developer, release manager, QA reviewer, client approver, viewer, and billing manager actions.

What you need

Organization membership and explicit project assignments.

What LaunchLayer automates

Planned permission matrix, audit events, and elevated confirmation for sensitive operations.

What remains external

Identity-provider policy and organization governance.

Exact setup steps

Not released; current account/workspace access remains unchanged.

How to verify it

Attempt every sensitive API as every role, including direct function invocation.

Common failures

Client-only gating, stale membership, cross-project access, or privilege escalation.

Security considerations

Credential changes, uploads, roles, deletion, and billing require recent authentication or elevated confirmation.

Related articles

Security and ownership.

Apple Wallet and Google Wallet passes

Planned

Planned provider adapters will support templates, preview, test issuance, and logs; dynamic updates remain unavailable until provider services work.

What this does

Will support event, membership, loyalty, reservation, and generic pass templates.

What you need

Provider account, identifiers, signing credentials, and data contract.

What LaunchLayer automates

Planned design, barcode/QR, serial/object ID, expiration, revocation, deep link, preview, and issuance log.

What remains external

Provider approval, signing ownership, and update service.

Exact setup steps

Not released.

How to verify it

Issue and open a test pass, validate barcode, expiration, revocation, and provider log.

Common failures

Invalid certificate, duplicate serial, malformed object, or unavailable update endpoint.

Security considerations

Signing keys never belong in generated client applications.

Related articles

Certificate Center; security and ownership.

Widget templates

Planned

Planned templates remain disabled until native build and physical-device verification workflows exist.

What this does

Will generate WidgetKit/SwiftUI and Android widget source templates plus data contracts.

What you need

Source project, rebuild path, refresh model, deep links, and compatible devices.

What LaunchLayer automates

Template source, empty/error states, preview data, and checklist.

What remains external

App-specific logic, authentication, compilation, signing, and device tests.

Exact setup steps

Feature flag remains off.

How to verify it

Build the extension/widget and test refresh, empty/error states, auth, and deep links on devices.

Common failures

Shared-data access, refresh limits, stale auth, or unsupported OS.

Security considerations

Expose only the minimum shared data required by the widget.

Related articles

Live Activities; native features.

Live Activities

Planned

Planned Live Activities remain disabled until native build and verification workflows exist.

What this does

Will generate attributes, content state, SwiftUI presentation, start/update/end examples, and Dynamic Island guidance.

What you need

Compatible iOS device, source rebuild, ActivityKit support, and remote server for remote updates.

What LaunchLayer automates

Template and payload contract only while the feature flag is off.

What remains external

Server, token rotation, APNs, app logic, signing, and device verification.

Exact setup steps

Not released.

How to verify it

Test local and remote start/update/end, token rotation/invalidation, payload limits, and supported OS behavior.

Common failures

Expecting direct arbitrary network fetch, stale push token, oversized payload, or unsupported device.

Security considerations

Protect activity tokens and validate every remote update.

Related articles

Widgets; Push Center.

Roadmap, requests, votes, and changelog

Planned

Planned roadmap states are controlled by administrators and do not constitute promises.

What this does

Will manage requests, unique votes, comments, subscriptions, official roadmap states, and verified release entries.

What you need

Authenticated users and authorized product administrators.

What LaunchLayer automates

Planned deduplication, rate limits, subscriptions, and changelog structure.

What remains external

Product commitment and release approval.

Exact setup steps

Not released.

How to verify it

Test duplicate voting, rate limits, admin-only status changes, subscriptions, and accurate release data.

Common failures

Duplicate requests, spam, unauthorized status change, or announcing unreleased work.

Security considerations

Rate-limit submissions/comments and audit official status changes.

Related articles

Plan limits and allowances.

Plan limits, catalogs, build credits, and allowances

Current customers stay on legacy_v1; launchlayer_v2 is an unpublished proposal until prices and backend enforcement are connected.

What this does

Centralizes plan entitlements and separates project, QA, approval, package, build-credit, and future push allowances.

What you need

An active subscription and the catalog version attached to it.

What LaunchLayer automates

Current UI reads enforced legacy allowances from one catalog; missing subscription versions resolve to legacy_v1.

What remains external

V2 prices, payment catalog records, add-ons, and migration decisions.

Exact setup steps

No action for existing customers; no silent migration occurs.

How to verify it

Compare pricing, meters, prompts, checkout, and server authorization against the same catalog before enabling V2.

Common failures

Hardcoded pricing drift, showing unenforced features, unmetered macOS builds, or silently downgrading legacy users.

Security considerations

Backend authorization—not pricing-page text—must enforce every sensitive entitlement.

Related articles

Cloud Build stages; security and ownership.