# Asking Questions
Source: https://docs.fastshot.ai/creating/asking-questions
How the AI clarifies your requirements before building
## Why the AI asks questions
Before generating code, the AI may ask 1-2 clarifying questions to make sure it builds what you actually want. This saves time by avoiding misunderstandings early.
## What it asks about
Common topics the AI clarifies:
* **Ambiguous features** — "When you say 'social features,' do you mean a feed, messaging, or both?"
* **Design preferences** — "Do you prefer a light or dark theme?"
* **Data structure** — "Should users be able to create categories, or are the categories fixed?"
* **Scope** — "Should the app include user authentication, or is it a standalone tool?"
## How to respond
* **Be specific** — "Both a feed and direct messaging" is better than "yes"
* **Add detail** — use your answer as a chance to add context you may have missed
* **Say "you decide"** — if you don't have a preference, let the AI make the call
The AI typically asks at most 1-2 questions. If your initial prompt is detailed enough, it may skip questions entirely and start building.
## After answering
Once the AI has enough information, it proceeds to:
1. Create a development plan (architecture, screens, design system)
2. Generate the code
3. Show you a live preview
From there, you can iterate with follow-up messages — no need to start over.
# Prompting Guide
Source: https://docs.fastshot.ai/creating/prompting-guide
Write better prompts for better apps
## General principles
The more specific your prompt, the better the result. Think of it like briefing a developer — the clearer the brief, the fewer revisions needed.
## Initial prompt tips
"Home screen with a feed, profile page, and settings" gives the AI a clear structure to work with.
"Users can create workouts with exercises, sets, and reps" tells the AI what models to build.
"Minimal design with soft pastels and rounded cards" is more actionable than "make it look nice."
"For college students managing study groups" helps the AI make UX decisions.
## Good vs. vague prompts
| Vague | Specific |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| Make me a food app | A recipe app where users can browse recipes by category, save favorites, and create shopping lists. Clean white design with food photography. |
| Build a social app | A photo-sharing app for dog owners. Users can post photos, follow other users, and like/comment. Instagram-style feed with a warm color scheme. |
| I need a business app | An expense tracker for freelancers. Log expenses by category, attach receipt photos, and view monthly summaries with charts. Dark theme. |
## Follow-up prompts
After the initial build, send focused follow-up messages to iterate:
**Design changes:**
* "Change the header color to dark blue"
* "Make the cards have more rounded corners"
* "Use a larger font size for headings"
**Feature additions:**
* "Add a settings screen with a logout button"
* "Add pull-to-refresh on the home feed"
* "Add a search bar at the top of the list"
**Bug fixes:**
* "The button on the profile page doesn't do anything"
* "The list items overlap on smaller screens"
Make one change at a time. "Change the header color and add a settings page" works, but you'll get better results with two separate messages.
## Things to avoid
* **Too abstract** — "Make it more modern" (what does that mean specifically?)
* **Too many changes at once** — keep follow-ups focused on one thing
* **Contradictory instructions** — "Make it minimal but add lots of animations and decorations"
# Starting a Project
Source: https://docs.fastshot.ai/creating/starting-a-project
How to create a new mobile app from scratch
## Describe your app
Open the editor at [fastshot.ai](https://fastshot.ai) and type a description of the app you want to build. Include:
* **Purpose** — what the app does and who it's for
* **Screens** — list the main screens (home, profile, settings, etc.)
* **Data** — what kind of data the app works with
* **Design** — colors, style, mood (e.g. "dark theme with blue accents")
Be specific. "A fitness tracker with workout logging, progress charts, and a dark theme" produces much better results than "make me a fitness app."
## Optional: add visual context
You can attach additional context to your first message:
* **Reference images** — upload screenshots or mockups to guide the design
* **Website URL** — paste a URL and Fastshot will analyze the site's design, colors, and layout to inspire your app
* **Moodboard images** — upload photos that capture the aesthetic you want
## What happens next
After you send your description:
1. **Clarifying questions** — the AI may ask 1-2 questions to understand your requirements
2. **Planning** — architecture, screens, navigation, and a design system (colors, fonts, spacing) are created
3. **Code generation** — production-ready React Native + Expo code is generated (about 5-7 minutes)
4. **Live preview** — a working preview appears in your browser
You'll see progress updates as each stage completes:
* Setting up template
* Starting mobile preview
* Starting AI agent
* Fine-tuning for your project
## After creation
Once the preview loads, you can:
* Test the app in your browser
* Scan the QR code to test on a physical device with [Expo Go](https://expo.dev/go)
* Send follow-up messages to make changes
Each project gets its own isolated environment with version control, so you can always roll back if needed.
# Using Reference Images
Source: https://docs.fastshot.ai/creating/using-reference-images
Upload screenshots and mockups to guide your app's design
## What are reference images?
Reference images are screenshots, mockups, or photos you upload alongside your prompt. The AI uses them as visual guidance when designing your app — matching colors, layout patterns, and overall aesthetic.
## How to use them
1. Click the image upload button in the chat input
2. Select one or more images from your device
3. Add a text description explaining what you want
4. Send the message
Always include a text description with your images. "Build an app that looks like this" with a screenshot works much better than uploading an image with no context.
## What works well
* **App screenshots** — screenshots of apps you admire for design inspiration
* **UI mockups** — wireframes or designs from Figma, Sketch, or similar tools
* **Moodboard photos** — images that capture the aesthetic you want (colors, textures, mood)
* **Sketches** — even hand-drawn sketches of your app layout
## What the AI extracts
From your reference images, the AI identifies:
* **Color palette** — primary, secondary, accent, and background colors
* **Layout patterns** — card-based, list-based, grid, etc.
* **Typography style** — bold headers, minimal text, dense content
* **Component styles** — rounded corners, shadows, borders, spacing
* **Overall mood** — playful, professional, minimal, bold
## Tips for best results
* Upload **2-3 images** for a well-rounded design direction
* Mix image types — one app screenshot + one moodboard photo works well
* If you want a specific element from an image, call it out: "Use the card style from this screenshot but with a dark background"
* Higher quality images produce better results
# Website Inspiration
Source: https://docs.fastshot.ai/creating/website-inspiration
Turn any website into a mobile app design
## How it works
Paste a website URL into the chat and Fastshot will analyze it to inspire your mobile app's design and content structure.
The system uses a headless browser to visit the website and extract:
* **Visual theme** — colors, fonts, imagery
* **Navigation structure** — menus, page hierarchy
* **Content sections** — headers, text blocks, media
* **Interactive elements** — forms, buttons, CTAs
## Using a website URL
1. Paste the URL directly into the chat input
2. Add context about what you want: "Build a mobile app inspired by this website"
3. Send the message
The analysis takes under 60 seconds. Once complete, the AI uses the extracted design information to generate your app.
You can combine a website URL with additional instructions. For example: "Use the color scheme from this site but simplify the navigation to 3 tabs."
## What gets analyzed
| Element | What's Extracted |
| -------------------- | --------------------------------------------------------- |
| Colors | Primary, secondary, and accent colors from the site's CSS |
| Typography | Font families, sizes, and weights |
| Images | Key visuals and their placement |
| Navigation | Menu structure and page links |
| Layout | Content sections and their arrangement |
| Interactive elements | Forms, buttons, and input fields |
## Tips
* **Public pages only** — the scraper can only access publicly visible pages (no login-required content)
* **Homepage is primary** — the homepage plus a few key linked pages are analyzed
* **Combine with text** — describe what aspects of the website you want to keep or change
* **Works with any site** — e-commerce, blogs, portfolios, SaaS landing pages, etc.
# How It Works
Source: https://docs.fastshot.ai/how-it-works
The AI workflow behind Fastshot
Fastshot uses a multi-stage AI pipeline to turn your text prompt into a working mobile app.
## The workflow
You describe your app in natural language. The AI may ask clarifying questions to understand your requirements.
The AI creates a development plan: app architecture, screens, navigation, data models, and design system (colors, typography, spacing).
AI generates production-ready React Native + Expo code: components, navigation, state management, styling, and assets.
A live preview appears in your browser. You can also scan a QR code to test on a physical device via Expo Go.
Send follow-up messages to refine the app. The AI makes targeted code updates without rebuilding from scratch.
When ready, deploy to the App Store and Google Play using Expo EAS builds.
## Tech stack
Your generated app uses:
| Technology | Purpose |
| ------------------- | ------------------------------------- |
| React Native | Cross-platform mobile framework |
| Expo | Managed build and deployment workflow |
| TypeScript | Type-safe code |
| Expo Router | File-based navigation |
| Zustand | State management |
| Supabase (optional) | Authentication, database, storage |
## What you can customize
After the initial build, you can:
* **Adjust design** — colors, fonts, spacing, layout
* **Add features** — new screens, buttons, forms, integrations
* **Fix issues** — describe a bug and the AI diagnoses and fixes it
* **Generate assets** — icons, logos, illustrations from text descriptions
* **Configure the app** — name, icon, splash screen
* **Connect integrations** — Supabase, RevenueCat, GitHub
# Introduction
Source: https://docs.fastshot.ai/index
Build mobile apps by chatting with AI
## What is Fastshot?
Fastshot is an AI-powered mobile app builder. Describe your app idea in plain English and get a fully functional React Native app for iOS and Android — no coding required.
Build your first app in 5 minutes.
Understand the AI workflow behind Fastshot.
## What can you build?
Fastshot creates cross-platform mobile apps including:
* Social and community apps
* Productivity and task management tools
* E-commerce and marketplace apps
* Health and fitness trackers
* Educational and content apps
* Finance and budgeting tools
## Key features
Describe what you want, the AI writes production-ready React Native code.
See your app update in real time as changes are made.
Generate icons, logos, and illustrations from text descriptions.
Publish to the App Store and Google Play directly from Fastshot.
## Ready to start?
Follow our quickstart guide to go from idea to working app in minutes.
# GitHub Integration
Source: https://docs.fastshot.ai/integrations/github-integration
Connect GitHub to manage your app's source code
## Why connect GitHub
GitHub integration is required for deploying your app to the App Store or Google Play. It also gives you:
* Full source code in your own repository
* Version history of all changes
* Ability to clone and develop independently
## Connecting GitHub
1. Click **Deploy** in the editor
2. Choose Android or iOS deployment
3. Authorize Fastshot to access your GitHub account
4. A repository is created automatically for your app
GitHub connection happens as part of the deployment flow. You don't need to set it up separately.
## What gets synced
* All app source code (components, screens, navigation, styles)
* Configuration files (`app.json`, `package.json`, etc.)
* Assets (icons, images, fonts)
* Expo build configuration
Code is pushed to GitHub automatically when you deploy. Each deployment creates a new commit with your latest changes.
## Using the source code
Once your code is on GitHub, you can:
* **Clone the repo** — work on the code locally with your own editor
* **Deploy independently** — use Expo CLI or EAS Build directly
* **Collaborate** — invite other developers to the repository
* **Customize further** — make changes that go beyond what the AI can do
The generated code uses standard React Native + Expo patterns, so any developer familiar with the stack can work with it.
## Repository structure
Your GitHub repository mirrors the project structure:
```
app.json # App configuration
App.tsx # Root component
app/ # Screens (Expo Router)
store/ # State management
constants/ # Theme and design tokens
assets/ # Images, icons, fonts
package.json # Dependencies
```
# Monetization
Source: https://docs.fastshot.ai/integrations/monetization
Add in-app purchases and subscriptions
## Overview
Fastshot supports monetization through in-app purchases and subscriptions. You can use:
* **Adapty** (default) — works out of the box, no extra setup needed
* **RevenueCat** (optional) — connect your own RevenueCat account for more control
## Using Adapty (default)
Adapty is included by default. Ask the AI to add monetization:
* "Add a premium subscription with monthly and yearly plans"
* "Add a paywall before the advanced features"
* "Create a freemium model with limited free usage"
The AI generates the paywall UI and subscription logic automatically.
## Using RevenueCat
If you prefer RevenueCat for managing purchases:
1. Create a [RevenueCat](https://www.revenuecat.com) account
2. Set up your products in the RevenueCat dashboard
3. Navigate to the monetization settings in your Fastshot project
4. Enter your RevenueCat API credentials
5. Tell the AI to use RevenueCat: "Add subscriptions using RevenueCat"
## What you can build
| Feature | Description |
| ------------------ | ------------------------------------------ |
| Subscriptions | Monthly, yearly, or custom billing periods |
| One-time purchases | Unlock features permanently |
| Paywalls | Gate content behind a purchase screen |
| Free trials | Offer trial periods before charging |
| Freemium | Limited free tier with paid upgrades |
## Cross-platform support
Both Adapty and RevenueCat work across iOS and Android. Products configured in Apple App Store Connect and Google Play Console are synced through the payment provider.
# Supabase Backend
Source: https://docs.fastshot.ai/integrations/supabase-backend
Add authentication, database, and storage to your app
## What Supabase provides
[Supabase](https://supabase.com) is an open-source backend platform. When connected to Fastshot, your app can use:
* **Authentication** — email/password, Google, and Apple sign-in
* **Database** — PostgreSQL with real-time subscriptions
* **Storage** — file and image uploads with public URLs
## Connecting Supabase
When your app needs backend features (user accounts, saving data, file uploads), the AI will prompt you to connect Supabase. An inline connect widget appears in the chat.
1. Click the connect button when prompted
2. Authorize Fastshot to access your Supabase project
3. The connection is established automatically
If you don't need a backend yet, you can skip the Supabase prompt. The AI will use local storage as a fallback. You can always connect later.
## Authentication
Once connected, you can add auth to your app:
* "Add a login screen with email and password"
* "Add Google sign-in"
* "Add Apple sign-in"
* "Add a password reset flow"
The AI generates the authentication UI and connects it to Supabase Auth. Session management is handled automatically.
## Database
Store and retrieve data with Supabase's PostgreSQL database:
* "Save user profiles to the database"
* "Add a favorites list that persists across sessions"
* "Show real-time updates when new items are added"
The AI generates the database queries, table structures, and real-time subscription code.
## Storage
Upload and manage files:
* "Let users upload profile photos"
* "Add image attachments to posts"
* "Store receipt photos with expenses"
Files are uploaded to Supabase Storage buckets with proper access control policies.
**Storage limits:**
* 10 MB per file
* Image files only (`image/*` MIME types) by default
## Without Supabase
If you choose not to connect Supabase, your app uses:
* **AsyncStorage** for local data persistence
* **Zustand** for in-memory state management
* No authentication or cloud storage
You can connect Supabase at any time to upgrade to cloud-based features.
# Android Deployment
Source: https://docs.fastshot.ai/publishing/android-deployment
Build and publish your app to Google Play
## Prerequisites
* [Expo account connected](/publishing/expo-connection)
* [GitHub account connected](/integrations/github-integration)
* [Google Play Console](https://play.google.com/console) account (\$25 one-time fee)
## Building for Android
1. Click **Deploy** in the Fastshot editor
2. Select **Android**
3. Choose a build type:
* **Preview** — for internal testing
* **Production** — for Google Play submission
4. Click **Start Build**
The build takes approximately 3-4 minutes. When complete, you'll get a download link for the APK file.
## Publishing to Google Play
1. **Download the APK** from the Expo build dashboard
2. **Open Google Play Console** and create a new app
3. **Upload the APK** to the appropriate track:
* Internal testing — for your team
* Closed testing — for invited testers
* Open testing — for public beta
* Production — for public release
4. **Complete the store listing:**
* App name and description
* Screenshots (phone and tablet)
* Feature graphic
* Privacy policy URL
* Content rating questionnaire
5. **Submit for review**
Start with internal testing to verify everything works before submitting to production.
## Store listing tips
* Use clear, descriptive screenshots that show your app's key features
* Write a concise description focusing on what users can do with the app
* Include a privacy policy (required by Google Play)
* Complete the content rating questionnaire accurately
## Troubleshooting
* **Build fails** — check the Expo build dashboard for error logs
* **APK not installing** — ensure "Install from unknown sources" is enabled on the test device
* **Missing app icon** — verify the app icon is set in [App Configuration](/working/app-config) before building
# Publishing Overview
Source: https://docs.fastshot.ai/publishing/app-publishing-overview
Deploy your app to the App Store and Google Play
## Prerequisites
Before publishing, you'll need:
Required for source code hosting. Connected during deployment.
Required for building native binaries. Free at [expo.dev](https://expo.dev).
Required for iOS only. \$99/year at [developer.apple.com](https://developer.apple.com).
Required for Android only. \$25 one-time at [play.google.com/console](https://play.google.com/console).
## Deployment flow
1. **Connect accounts** — link GitHub and Expo to your Fastshot project
2. **Choose platform** — select Android, iOS, or both
3. **Build** — Fastshot triggers an Expo EAS build (3-4 minutes)
4. **Download/submit** — get the build artifact or submit directly to the store
5. **Publish** — complete the app store listing and submit for review
## Platform guides
Set up your Expo account and access token.
Build an APK and publish to Google Play.
Build and submit to the App Store.
## Before you publish
Make sure you've:
* Tested the app on a physical device via Expo Go
* Set the correct app name and icon in [App Configuration](/working/app-config)
* Connected [Supabase](/integrations/supabase-backend) if your app uses a backend
* Verified all features work as expected
# Expo Connection
Source: https://docs.fastshot.ai/publishing/expo-connection
Connect your Expo account for app builds
## What is Expo?
[Expo](https://expo.dev) is a platform for building and deploying React Native apps. Fastshot uses Expo EAS (Expo Application Services) to create native iOS and Android builds from your project.
## Setting up Expo
1. **Create an account** — sign up at [expo.dev](https://expo.dev) (free)
2. **Create an access token:**
* Go to your Expo account settings
* Navigate to **Access Tokens**
* Click **Create Token**
* Copy the token
3. **Connect to Fastshot:**
* Click **Deploy** in the Fastshot editor
* Paste your Expo access token when prompted
* The token is stored securely and used for all future builds
Keep your access token secret. Don't share it or commit it to public repositories.
## What Expo handles
When you deploy from Fastshot, Expo:
* Pulls your latest code from GitHub
* Installs dependencies
* Builds a native binary (APK for Android, IPA for iOS)
* Signs the build with the appropriate certificates
* Provides a download link or submits directly to the store
## Build types
| Type | Purpose | Use case |
| ----------- | ---------------------------- | -------------------------------------- |
| Development | Local testing with dev tools | Debugging on your device |
| Preview | Internal testing | Sharing with testers before release |
| Production | App store submission | Publishing to App Store or Google Play |
## Monitoring builds
After starting a build, you can track its progress on the [Expo build dashboard](https://expo.dev). Build logs are available there if anything goes wrong.
# iOS Deployment
Source: https://docs.fastshot.ai/publishing/ios-deployment
Build and submit your app to the App Store
## Prerequisites
* [Expo account connected](/publishing/expo-connection)
* [GitHub account connected](/integrations/github-integration)
* [Apple Developer Program](https://developer.apple.com/programs/) membership (\$99/year)
## Building for iOS
1. Click **Deploy** in the Fastshot editor
2. Select **iOS**
3. Confirm your Expo token and Apple Developer account are connected
4. Click **Start Build**
Expo handles the entire build process:
* Pulls code from GitHub
* Creates and manages signing certificates
* Builds the IPA binary
* Submits to App Store Connect
## Publishing to the App Store
1. **Open App Store Connect** at [appstoreconnect.apple.com](https://appstoreconnect.apple.com)
2. **Find your build** — it should appear automatically after Expo submits it
3. **Complete the app listing:**
* App name and subtitle
* Description and keywords
* Screenshots for each device size (iPhone, iPad if applicable)
* App icon (1024x1024)
* Privacy policy URL
* Age rating
* App category
4. **Submit for App Review**
Apple's review process typically takes 1-2 days. Make sure your app follows the [App Store Review Guidelines](https://developer.apple.com/app-store/review/guidelines/).
## App Store requirements
* Your app must have a clear purpose and function as described
* All features shown in screenshots must work
* A privacy policy is required
* Apps that collect user data must explain what data is collected and why
* No placeholder content or lorem ipsum text
## Troubleshooting
* **Build fails** — check the Expo build dashboard for error logs; common issues include expired certificates or provisioning profiles
* **Rejected by App Review** — read the rejection reason carefully; common causes include crashes, broken features, or guideline violations
* **Certificate issues** — Expo manages certificates automatically; if problems occur, regenerate the access token
* **Missing metadata** — App Store Connect highlights required fields that are incomplete
# Quickstart
Source: https://docs.fastshot.ai/quickstart
Go from idea to working app in 5 minutes
## Step 1: Describe your app
Visit [fastshot.ai](https://fastshot.ai) and open the editor. Type a description of the app you want to build.
For best results, include:
* **Purpose** — what the app does
* **Target users** — who it's for
* **Core features** — minimum required functionality
* **Design goals** — desired look and feel
The more specific your description, the better the result. "A fitness tracker with workout logging, progress charts, and a dark theme" works much better than "make me a fitness app."
Click **Send**. If you're new to Fastshot, you'll be prompted to sign up or log in. Your prompt is saved automatically.
## Step 2: Review and refine
The AI may ask 1-2 clarifying questions before building. Answer them to help refine the plan.
Code generation takes about **5-7 minutes** for the first version. When it's done, a live preview appears in the right panel.
The browser preview is an approximation. For full accuracy, test on a physical device using the Expo Go app — scan the QR code shown next to the preview.
## Step 3: Iterate
Send follow-up messages to adjust your app:
* "Change the header color to dark blue"
* "Add a settings screen with a logout button"
* "Make the cards have rounded corners"
Each follow-up triggers a targeted code update, not a full rebuild.
## Step 4: Deploy
When you're happy with your app, deploy it to the App Store or Google Play. See [Publishing](/publishing/app-publishing-overview) for details.
## Next steps
Write better prompts for better results.
Learn how to preview and test your app.
Connect Supabase for auth, database, and storage.
Generate and manage app icons, images, and more.
# FAQ
Source: https://docs.fastshot.ai/support/faq
Frequently asked questions about Fastshot
## General
No. Fastshot generates production-ready code from text descriptions. You build and iterate entirely through chat.
Cross-platform mobile apps for iOS and Android. Common examples include social apps, productivity tools, e-commerce apps, fitness trackers, educational apps, and finance tools.
No. Fastshot is specifically designed for mobile apps using React Native and Expo. For websites, consider other tools.
Yes. Fastshot generates TypeScript React Native code with proper structure, types, navigation, and state management — ready for app store submission.
Yes. When you connect GitHub, your full source code is pushed to your own repository. You can clone it, modify it, and deploy it independently.
## Building
The first version takes about 5-7 minutes. Follow-up changes are faster since the AI only modifies what's needed.
Yes. Upload screenshots, mockups, or moodboard images. You can also paste a website URL for the AI to analyze and draw inspiration from.
Credits are based on actual AI usage (token consumption). Simple changes cost less than full app generation. Check your balance in the credits page.
Yes. Tell the AI "change app name to MyApp" or upload a new icon. These settings are updated in your app configuration.
## Testing
Yes. Install Expo Go on your device and scan the QR code shown in the preview panel.
The browser preview is an approximation. Native components (navigation bars, modals, date pickers) render differently on real devices. Always test on a physical device for full accuracy.
Click the "Restart Metro" button. If that doesn't help, ask the AI to "restart the preview with cache reset."
## Deployment
Connect GitHub and Expo, then click Deploy and select iOS. Fastshot handles the build and submission to App Store Connect. See the [iOS deployment guide](/publishing/ios-deployment).
Connect GitHub and Expo, then click Deploy and select Android. Download the APK and upload it to Google Play Console. See the [Android deployment guide](/publishing/android-deployment).
For iOS: yes, an Apple Developer Program membership ($99/year). For Android: yes, a Google Play Console account ($25 one-time fee). These are required by Apple and Google, not by Fastshot.
## Integrations
Only if your app needs user accounts, cloud storage, or a database. Without Supabase, data is stored locally on the device.
Yes. Fastshot supports in-app purchases and subscriptions via Adapty (built-in) or RevenueCat (optional). See the [Monetization guide](/integrations/monetization).
# Troubleshooting
Source: https://docs.fastshot.ai/support/troubleshooting
Solutions for common issues
## Preview issues
1. Click the **Restart Metro** button in the preview panel
2. If that doesn't help, ask the AI: "restart the preview with cache reset"
3. Check that your browser allows the preview iframe to load
The preview may take a moment to compile after changes are made. Look for the build state indicator.
Runtime errors display with a count badge in the preview panel.
* Click **Fix All Errors** to let the AI diagnose and fix them automatically
* Or describe the error to the AI: "I'm seeing an error on the home screen"
The AI can read Metro logs to identify the root cause.
This is expected. The browser preview uses React Native's web renderer, which approximates but doesn't perfectly match native rendering.
Native differences include:
* Navigation bars and tab bars
* Modal presentations
* Date and time pickers
* Platform-specific animations
* Shadows and elevation
Always test on a physical device with Expo Go for the accurate experience.
These features require native device APIs that aren't available in the browser preview. Test them on a physical device using Expo Go.
## Build and deployment issues
Check the [Expo build dashboard](https://expo.dev) for detailed error logs. Common causes:
* Missing or invalid app icon
* Invalid `app.json` configuration
* Expired Expo access token — regenerate in your Expo account settings
* iOS: expired Apple Developer certificates
* Make sure you're logged into GitHub in your browser
* Check that you've authorized Fastshot to access your GitHub account
* Try revoking and re-granting access in GitHub Settings > Applications
* Verify your access token is valid at [expo.dev](https://expo.dev) under Account > Access Tokens
* Create a new token if the current one has expired
* Make sure you're pasting the full token without extra spaces
## App behavior issues
Describe the issue to the AI:
* "The save button on the profile screen doesn't do anything"
* "Tapping a list item should open the detail screen but nothing happens"
The AI will check the code, identify the problem, and fix it.
* If using local storage: data resets when the app is reloaded in the browser preview. Test on a physical device for persistent storage.
* If using Supabase: check that your Supabase project is connected and the database tables exist.
Ask the AI to check for errors: "The app crashes when it opens." The AI will inspect the Metro logs and code for issues like missing imports, undefined variables, or configuration errors.
## Account and credits
* Send focused, one-change-at-a-time messages (more efficient than large multi-change requests)
* Simple UI tweaks cost less than full feature additions
* Check your balance on the credits page
* Check your email address is correct
* Try resetting your password
* Clear browser cookies and try again
## Getting more help
Join the [Fastshot Discord community](https://discord.com/invite/4UHnKKmj9q) to ask questions and get help from other users and the team.
# App Configuration
Source: https://docs.fastshot.ai/working/app-config
Customize your app's name, icon, splash screen, and settings
## What you can configure
Your app's configuration is stored in `app.json`. You can update any setting through chat — no need to edit files manually.
| Setting | Description | Example |
| ------------- | ------------------------------ | ----------------------------------------- |
| App name | Display name on home screen | "Change app name to FitTrack" |
| App icon | Home screen icon | "Update the app icon" |
| Splash screen | Loading screen image and color | "Make splash screen background dark blue" |
| Version | App version number | "Set version to 1.2.0" |
| Scheme | Deep link URL scheme | "Set deep link scheme to fittrack" |
## Updating configuration
Tell the AI what you want to change:
* "Change the app name to MyApp"
* "Set the splash screen background color to #1a1a2e"
* "Update the app icon to the one I uploaded"
Changes apply immediately to the preview. For app store builds, the updated configuration is included automatically.
## Design system
Your app's design system is established during initial generation and includes:
* **Color palette** — primary, secondary, accent, background, and text colors
* **Typography** — font families, sizes, and weights
* **Spacing** — consistent spacing scale across the app
* **Border radius** — rounded corners for cards, buttons, and inputs
To modify the design system:
* "Change the primary color to indigo"
* "Use a more rounded style for all buttons and cards"
* "Make the body text slightly larger"
## App structure
Fastshot generates apps with this structure:
```
app.json # App configuration
App.tsx # Root component
app/ # Screens (file-based routing)
(tabs)/
_layout.tsx # Tab navigation layout
index.tsx # Home screen
[screen].tsx # Additional screens
store/ # State management (Zustand)
constants/ # Colors, typography, theme
assets/ # Images, icons, fonts
```
Navigation uses [Expo Router](https://docs.expo.dev/router/introduction/) with file-based routing. State management uses [Zustand](https://zustand-demo.pmnd.rs/) for simplicity and performance.
# Asset Management
Source: https://docs.fastshot.ai/working/asset-management
Generate and manage images, icons, and logos
## AI-generated assets
Fastshot can generate images from text descriptions. Ask in the chat:
* "Generate an app icon with a blue gradient and a rocket"
* "Create a logo for a fitness app called FitTrack"
* "Make an illustration of a person meditating"
Supported asset types:
| Type | Description |
| ------------ | ------------------------------------ |
| App icon | Home screen icon for iOS and Android |
| Logo | Brand logo for use inside the app |
| Icon | UI icons at various sizes |
| Illustration | Decorative images and graphics |
| Background | Full-screen background images |
| Photo | Realistic photo-style images |
Generation takes 10-30 seconds per image.
## Uploading your own assets
You can upload images directly:
1. Open the assets panel in the editor
2. Click the upload button
3. Select files from your device
4. Images are added to your project's `assets/` folder
**Limits:**
* Maximum 20 files per project
* Standard image formats supported (PNG, JPG, SVG)
## Using assets in your app
Once an asset is in your project, tell the AI how to use it:
* "Use the uploaded logo as the header image"
* "Set the new icon as the app icon"
* "Use this background image on the login screen"
The AI updates your code to reference the asset from the `assets/images/` directory.
## Splash screen and app icon
To update your app's splash screen or home screen icon:
* "Change the splash screen background to dark blue"
* "Update the app icon to the one I just uploaded"
These changes update `app.json` and take effect on the next build.
# Making Changes
Source: https://docs.fastshot.ai/working/making-changes
Iterate on your app with follow-up messages
## How iteration works
Send a follow-up message describing what you want to change. The AI makes targeted code updates — it doesn't rebuild from scratch.
Each change follows this cycle:
1. You describe the change
2. AI modifies the relevant code
3. App rebuilds automatically
4. Preview updates with your changes
5. A version checkpoint is saved
## Types of changes
**Design changes**
* "Change the background color to dark gray"
* "Make the cards have rounded corners and a subtle shadow"
* "Use a larger font for the page title"
**Feature additions**
* "Add a settings screen with a dark mode toggle"
* "Add pull-to-refresh to the home screen"
* "Add a search bar that filters the list"
**Screen additions**
* "Add a profile page that shows the user's name and email"
* "Add an onboarding flow with 3 intro slides"
**Bug fixes**
* "The save button doesn't do anything when tapped"
* "Items overlap on smaller screens"
* "The back button goes to the wrong screen"
**Configuration**
* "Change the app name to FitTracker"
* "Update the app icon"
## Tips for effective iteration
Focused messages produce better results than bundling multiple changes together.
"Make the header 60px tall with white text" is better than "fix the header."
"On the home screen, move the search bar above the list" tells the AI exactly where to look.
For bugs, describe what happens vs. what you expected. The AI will diagnose and fix it.
## Version history
Every change creates a version checkpoint. You can:
* **Browse history** — see what changed at each step
* **Roll back** — revert to a previous version if a change didn't work out
If a change goes wrong, you can always roll back. Don't hesitate to experiment.
# Preview & Testing
Source: https://docs.fastshot.ai/working/preview-and-testing
Test your app in the browser and on your phone
## Browser preview
A live preview of your app appears in the right panel of the editor. It updates automatically as the AI makes changes.
The preview shows your app running through a React Native web build. It's a good approximation, but some elements may look slightly different than on a real device.
The browser preview cannot simulate native device features like camera, biometrics, NFC, Bluetooth, push notifications, or native date pickers. Use a physical device for testing these features.
## Testing on your phone
For the most accurate experience, test on a physical device:
1. Install [Expo Go](https://expo.dev/go) on your iOS or Android device
2. Open the QR code tab in the preview panel
3. Scan the QR code with your device camera (iOS) or the Expo Go app (Android)
4. Your app loads on your device with live updates
Your phone and computer need to be on the same network for live preview to work.
## What works where
| Feature | Browser Preview | Physical Device |
| --------------------- | :-------------: | :-------------: |
| UI layout and styling | Yes | Yes |
| Navigation | Yes | Yes |
| State management | Yes | Yes |
| Forms and inputs | Yes | Yes |
| Camera | No | Yes |
| Biometrics | No | Yes |
| Push notifications | No | Yes |
| Native date pickers | No | Yes |
| Platform-specific UI | Approximate | Accurate |
## Preview controls
* **Restart Metro** — click the restart button if the preview stops responding
* **Cache reset** — ask the AI to "restart the preview with cache reset" for a clean rebuild
* **Error display** — runtime errors show with a count badge; click "Fix All Errors" to let the AI diagnose and fix them
## Preview states
| State | What's happening |
| -------- | -------------------------------------------------- |
| Loading | Setting up the preview environment |
| Building | Compiling your app code |
| Ready | App is running and interactive |
| Coding | AI is editing code — preview will update when done |
| Error | Build failed — check the error message |