App & Website Launch Guide

Updated

Once your app development is complete, the final step is to package the app, submit it to an app store, pass the store review, and make it available to users.

This guide walks you through the process of publishing a locally developed app to the Apple App Store and Google Play, starting from the point where you have exported the completed source code from Sketchflow.

iOS App Publishing to the Apple App Store

Prerequisites

Download the code ZIP from Sketchflow Export, extract it locally and open the ios file.

Before publishing an iOS app, make sure you have the following ready:

  • Apple Developer Program membership: Enroll as an individual or organization. The Apple Developer Program currently costs US$99 per membership year, with local pricing varying by region. Organizations need to provide a D-U-N-S Number for verification.

  • A Mac with Xcode: Open the exported iOS project in Xcode, complete local debugging, and test the app on a real device before preparing the release build (which can be done in Sketchflow emulator and automated testing feature).

  • App information: Prepare the app name, subtitle, description, keywords, category, app icon, screenshots, age rating information, support URL, and other App Store metadata.

  • Privacy information: Prepare a publicly accessible privacy policy URL and determine what data the app and any third-party SDKs collect or use.

  • Review information: If the app requires an account or login to access its main functionality, prepare a working test account and clear instructions for Apple's review team.

Official guides: Become a member in Apple Developer Program, App Store Connect Help

Step 1: Open Source Code and Prepare the Release Build

Download the iOS source code in Sketchflow and extract it locally. Open the project in Xcode and make sure the project builds and runs correctly on a real iPhone.

Before creating the release build, check the Bundle Identifier, version number, build number, app icon, signing settings, and required capabilities.

The Budle ID in Xcode must match the Bundle ID associated with the app in App Store Connect.

If you have configure your Apple Developer team and signing settings in Sketchflow platform, go straight to archive in Xcode. If not, configurethe settings manually.

Once everything has been tested, select a release configuration and choose Product → Archive in Xcode. Xcode creates an archive containing the release build of your app.

Exporting the source code or creating an Xcode archive does not mean that your app has been
published. The build still needs to be uploaded to App Store Connect, associated with an app record,
tested if necessary, and submitted for review.

Official guide: Upload builds to App Store Connect

Step 2: Create an App Record and Upload the Build

Before uploading a build, sign in to App Store Connect and create an app record under Apps → + → New App. Enter the app name, primary language, Bundle ID, SKU, and other required information.

After the app record has been created, return to Xcode's Organizer, select the archive you created, and choose Distribute App. Follow the distribution steps to validate and upload the build to App Store Connect.

Once processing is finished, the build will appear in the app's build list.

Official guides: App Store Connect Workflow, Upload Builds

Step 3: Complete the Listing and Privacy Information, Submit for Review

Once the build is available, complete the information required for the App Store product page. This includes the app description, screenshots, category, age rating, support information, and version release notes.

And you must provide a Privacy Policy URL and complete Apple's App Privacy questionnaire.

Make sure the submitted build, store listing, privacy information, and review instructions are consistent with the actual app.

In App Store Connect, select the app version you want to release and make sure the correct build is attached to it. Click Add for Review, then Submit for Review.

The app will enter Apple's App Review process. Apple may approve the app, reject it with an explanation, or request additional information.

Official guides: Manage App Privacy, Submit an App

Step 4: Release the App on the App Store

After the app passed App Review, you can release it according to the release settings configured in App Store Connect. Depending on your settings, the app can be released automatically, manually, or using Apple's available release options.

Android App Publishing to Google Play

Prerequisites

Download the code ZIP from Sketchflow Export, extract it locally and you'll get the Android source code files.

Before publishing an Android app, prepare the following:

  • Google developer account: Create a developer account with the required identity verfication. Full distribution currently requires a one-time US$25 registration fee.

  • Android Studio: Open the exported Android project, complete local debugging, and test the app on real Android devices (which can be done in Sketchflow emulator and automated testing feature).

  • Applictaion ID: Confirm the app's unique package/applictaion ID before publishing. Keep the same applictaion ID for future updates.

  • Signing key: Prepare an upload keystore and signing key. Keep the keystore and credentials secure because they are important for publishing future updates.

  • App information: Prepare the app name, short description, full description, app icon, screenshots, category, contact information, privacy policy, and other Google Plat store listing information.

  • Privacy and data information: Review the data collected or shared by the app and its third-party SDKs so that you can complete Google Play's required declarations accurately.

Official guides: Google Play Console, Create and Set Up Your App

Step 1: Export the Code and Generate a Release AAB

Download the Android source code from Sketchflow and extract it locally. Open the Project in Android Studio, sync the project, and make sure it builds and runs correctly on a real Android device.

Before creating the release build, check the Application ID, version code, version name, target SDK, app icon, permissions, and other release settings.

Make sure the Applictaion ID remains consistent with the idenity you intend to us on Google Play.

For a production release, generate a signed Android App Bundle (AAB) in Android Studio, use Build → Generate Signed Bundle / APK, select Android App Bundle, choose the release configuration, and sign the bundle using your upload keystore.

The resulting file will typically look like:

app-release.aab

Google Play uses Android App Bundles to generate optimized APKs for different device configurations, so the AAB is the standard format for new Google Play releases.

Step 2: Create the App in Google Play Console

Sign in to Google Play Console and select Create app. Enter the app name, default language, app or game type, free or paid status, and a contact email.

After creating the app, Google Play Console provides a setup dashboard showing the remaining tasks required before the app can be release.

Official guide: Create and Set Up Your App

Step 3: Complete the Google Play Store Listing and App Information

Before releasing the app, complete the store listing in Google Play Console. Provide the app name, short description, full description, app icon, screenshots, category, contact information, and privacy policy URL as required.

You also need to complete the relevant app content and data declarations. In particular, review the app's data collection and sharing practices, including data handled by third-party SDKs and services.

Step 4: Complete the Required Testing for New Personal Accounts

If your Google Play developer account is a personal account created after November 13, 2023, Google currently requires additional testing before you can apply for production access.

You must run a closed test with at least 12 testers who remain opted in continuously for at least 14 days. After meeting these requirements, you can apply for production access from the Play Console dashboard.

This requirement does not apply in the same way to all developer accounts, so check the requirements
shown in your own Play Console before planning the launch timeline.

Official guide: App Testing Requirements for New Personal Developer Accounts

Step 5: Submit the App for Production

After completing the required setup and testing, create a production release in Test and release → Production. Select the release containing your signed AAB, review the release information, and start the rollout.

Official guide: Prepare and Roll Out a Release

Website Publishing

Prerequisites

Before publishing your website, make sure you have the following ready:

  • Exported full-stack source code: Download the completed project from Sketchflow and extract it locally.

  • A hosting service: Choose a hosting provider that supports your application's technology stack. Common options include Vervel, AWS Amplify, AWS, Netlify, and other cloud hosting provides. The appropriate database requirements, and expected traffic.

  • A domain name: Purchase a custom domain from a domain register, such as example.com.

  • Production environment variables: Prepare the API keys, database connection strings, authentication credentials, third-party credentials and other configuration values required by the application (which can be completed and managed in Sketchflow).

  • Production database and external services: If the application uses a database, authentication provider, file storage, payment service, email service, or other external services, make sure the required production resources are ready (which can be done in Sketchflow).

Useful guides: Vercel Deployment Documentation, AWS Amplify Hosting

Step 1: Download the Code, Deploy the Full-Stack Project to a Hosting Service

Download the full-stack source code from Sketchflow and extract it locally. Before deploying the project, open the code in your preferred development environment and check the project's documentation and configuration files to identify the required installation commands, build commands, environment variables, and external services.

Choose a hosting service that supports your application's artchitecture and framework.

For different hosting providers, the exact interface may be different, but the basic process is similar: create a project, connect or upload your source code, configure the build settings, and then deploy the application to production.

After the first deployment, the hosting platform normally provides a temporary deployment URL. Open this URL and test the website before connecting your custom domain.

Useful guides: Deploy a Project with Vervel, Deploying an Application to Amplify Without a Git Repository

Step 2: Connect a Custom Domain

Before connecting your custom domain, please configure environment variables, external services, production database and backend first. Once the production deployment has been tested, connect your custom domain.

For example, if you purchased: example.com, you can add it to your hosting project and then configure the required DNS records at your domain register.

The exact DNS recorda depend on the hosting provider. For example, a hosting platform may require an A record for the root domain and a CNAME record for a subdomain such as www.

Adding the DNS records, wait for the changes to propagate and verify that the domain is correctly connected to the production deployment.

Important: Do not delete existing DNS records without check what they are used for.

Vercel Example: Setting up a Custom Domain

Step 3: Enable HTTPS and verify the Domain

After the custom domain has been connected, make sure the website is available through HTTPS.

Many modern hosting platforms automatically provision and manage SSL/TLS certificates when you connect a custom domain. For example, AWS Amplify can provide a managed certificate for a connected custom domain.

Once the certificate is active, verify that: https://example.com loads correctly and that HTTP traffic is redirected to HTTPS when appropriate.

Also check:

  • The certificate is valid and not expired.
  • The correct domain is covered by the certificate.
  • Both the root domain and www domain work as intended, if both are configured.
  • API requests use HTTPS.
  • No mixed-content warnings appear in the browser.

Step 4: Make the Website Public

After the production deployment, domain, HTTPS, backend, database, and core features have all been verified, the website is ready to be shared publicly.

At this point, users can access the website through your custom domain.