Bubble Docs
  • Introduction
  • New? Start Here
  • What is Bubble?
  • The Glossary
  • User manual
    • Getting started
      • What is Bubble?
      • Building your first app
        • Planning features
        • Database structure
        • Design and UX
        • eCommerce and payments
          • Shopping cart
          • Checkout page
          • One-time payments
          • Subscriptions
          • Marketplace
      • Creating and managing apps
      • The Bubble editor
        • Tabs and sections
          • Design tab
            • The element tree
            • The property editor
          • Workflow tab
          • Data tab
          • Styles tab
          • Plugins tab
          • Settings tab
            • Application settings
              • Custom headers/body
              • Visual settings
              • Social media sharing
              • Translating your app
              • Email settings
              • Collaboration
            • Custom domain and DNS
          • Logs tab
        • Tools
          • Key features
          • The search tool
          • The Issue Checker
          • The element tree
          • The element property editor
          • The debugger
          • Notes
        • Previewing your app
      • Transitioning to Bubble from...
        • JavaScript
        • HTML and CSS
        • SQL
    • Design
      • Elements
        • The element hierarchy
          • The element tree
        • The page
        • Containers
          • Groups
          • Repeating groups
          • Table elements
          • Popups
          • Floating groups
          • Group focus
        • Visual elements
        • Input forms
          • Text and numbers
          • Dates and time
          • File uploads
          • Selection controls
        • Reusable Elements
      • Styling
        • Color variables
        • Font variables
        • Styles
        • Custom Fonts
      • Responsive design
        • Building responsive pages
        • Legacy articles
          • The Basics (Legacy)
          • Building Responsive Pages (Legacy)
          • Migrating Legacy Pages
          • Tips When Designing (Legacy)
      • Templates
      • The Component Library
      • Importing from Figma
    • Data
      • The database
        • Data types and fields
        • Creating, saving and deleting data
        • Finding data
        • Displaying data
        • Protecting data with privacy rules
        • The database editor
        • Export/import data
          • Exporting data
          • Importing data (CSV)
        • Working with location data
        • Using Algolia
        • Database structure by app type
          • Marketplace Apps
          • Directory & Listings Apps
          • Social Network Apps
          • SaaS Apps
          • Project Management Apps
          • CRM Apps
          • Professional Services Apps
          • On-demand Apps
          • Documentation/ CMS Apps
          • Applicant Tracking System (ATS) Apps
          • Portfolio Apps
          • Gallery Apps
          • Online Store / Ecommerce Apps
          • Blog Apps
          • Messaging App
          • Dashboards
          • Building Block Apps
          • Bubble as a backend
      • Files
      • Images
      • Static data
        • App texts (translations)
        • Option sets
      • Temporary data
        • Custom states
        • URL parameters
      • User accounts
        • Authentication plugins
          • Facebook plugin
          • Fitbit plugin
          • Google plugin
          • Instagram plugin
          • LinkedIn plugin
          • Pinterest plugin
          • Slack plugin
          • Wistia plugin
          • YouTube plugin
        • Cookies set by Bubble
      • Time, dates and time zones
    • Logic
      • The frontend and backend
      • Workflows
        • Events
          • Frontend events
            • Recurring workflows
            • Custom events
          • Backend events
            • Database trigger events
        • Actions
        • API Workflows
      • Dynamic expressions
      • Conditions
      • Navigation
        • Single-page applications (SPA)
        • Multi-page applications
        • Page slugs
    • Workload
      • Understanding workload
        • Activity types
        • The workload calculation
        • Client-side and server-side processing
      • Tracking workload
        • Measuring
          • Using App Metrics
        • Monitoring
          • Workload notifications
          • Infinite recursion protection
      • Optimizing workload
        • Optimization framework
        • Optimization checklist
          • Page load
          • Searches
          • Workflows and actions
          • Backend workflows
        • Agency showcases
          • Minimum Studio
          • Neam
          • Support Dept
    • Security
      • Bubble's security features
      • Planning app security
      • Client-side and server-side
      • Bubble account security
      • App security
      • Page security
      • Database security
      • API security
        • API Connector security
        • Data API security
        • Workflow API security
      • Flusk
        • Overview
        • Flusk plan features
        • Getting started with Flusk
        • Flusk security tools
          • The Issues Explorer
          • Issue details
          • Tools and settings
            • Pages rating
            • Database rating
        • Flusk FAQ
      • Cookies
      • Security checklist
    • Publishing your app
      • Web app
      • Native mobile app
        • Global native mobile settings
        • iOS App Store
        • Google Play Store
        • Publishing FAQ
    • AI
      • Generate apps with AI
        • About AI app generation
      • AI page designer
      • Connect to AI agents
    • Maintenance
      • Collaborators
      • Version control
        • Best practices: Version control
        • Transitioning from the legacy version control
        • Terminology: Version control
        • Version Control (legacy)
      • Commenting
      • Database maintenance
        • Copying the database
        • Restoring database backups
        • Bulk operations
          • Bulk operation methods compared
        • Wiping change history
      • Performance
        • Hard limits
        • Capacity Usage (legacy)
        • Notes on queries
      • SEO
        • Introduction to SEO
        • SEO: App
        • SEO: Page
      • Testing and debugging
        • Introduction to testing and debugging
        • The debugger
        • The server logs
        • Supported browsers
      • API workflow scheduler
    • Integrations
      • API
        • Introduction to APIs
          • What is a RESTful API?
        • The Bubble API
          • Bubble API terminology
          • Authentication
            • How to authenticate
            • No authentication
            • As a User
            • As an admin
          • The Data API
            • Data API Privacy Rules
            • Data API endpoints
            • Data API requests
          • The Workflow API
            • Workflow API privacy rules
            • Workflow API endpoints
            • API workflows
              • Creating API workflows
              • Scheduling API workflows
              • Recursive API workflows
              • API Workflow Scheduler
              • Case: Stripe notifications
        • The API Connector
          • Authentication
          • API Connector security
          • API guides
            • OpenAI
              • Authentication
              • Calls
                • ChatGPT
                  • Chat
            • Google Translate
              • How to setup Google API keys
          • Streaming API
        • API security
        • Plugins that connect to APIs
        • API Glossary
      • Plugins
        • What Plugins Can Do
        • Installing and using Plugins
        • Authentication plugins
        • Special Plugins
      • SQL Database Connector
      • Bubble App Connector
      • WorkOS
        • WorkOS SSO
        • WorkOS API
    • Infrastructure
      • Sub-apps
      • Bubble release tiers
      • Hosting and scaling
        • How Bubble hosting works
        • Scaling with Bubble
        • CDN (Cloudflare)
        • Bubble app names
        • Domain and DNS
      • Compliance
        • GDPR
        • SOC 2 Type II
        • HIPAA
        • Other frameworks and standards
    • Bubble for Enterprise
      • Hosting and infrastructure
        • Dedicated instance
          • The Dedicated editor experience
          • Technical specs
          • Main cluster dependencies
          • Customizable options
          • Migration process
            • Pre-migration
            • During migration
            • Post-migration
      • Security and compliance
        • Single sign-on (SSO)
        • GDPR
        • SOC 2 Type II
        • HIPAA
        • Other frameworks
        • Bubble's security features
      • Admin and collaboration
      • Priority support
      • Billing and Payment Guideline for Dedicated Instances
  • Core Reference
    • Using the core reference
    • Bubble's Interface
      • Design tab
      • Design tab (Legacy)
      • Workflow tab
      • Data tab
      • Styles tab
      • Styles tab (Legacy)
      • Plugins tab
      • Settings tab
      • Logs tab
      • Template tab
      • Toolbar
      • Top and context menu options
      • Deployment and version control
        • Deployment & Version Control Dropdown (legacy)
      • Notes
    • Elements
      • General properties
      • General properties (Legacy)
      • Styling properties
      • Styling Properties (Legacy)
      • Responsive Properties
      • Responsive Properties (Legacy)
      • Conditional formatting
      • States
      • Page Element
        • Page Element (Legacy)
      • Visual Elements
      • Containers
      • Container Layout Types
      • Containers (Legacy)
      • Input Forms
      • Reusable Elements
      • Element Templates (legacy)
    • Workflows
    • Events
      • General events
      • Element events
      • Custom events
      • Recurring event
      • Database trigger event
    • Actions
      • Account
      • Navigation
      • Data (things)
      • Email
      • Element
      • Custom
    • Data
      • Data Sources
      • Operators and comparisons
      • Search
      • Privacy
    • Styles
    • API
      • The Bubble API
        • The Data API
          • Authentication
          • Data API endpoints
          • Data API requests
        • The Workflow API
      • The API Connector
        • Authentication
        • Adding calls
    • Bubble-made Plugins
      • AddtoAny Share Buttons
      • Airtable
      • API Connector
      • Blockspring
      • Box
      • Braintree
      • Bubble App Connector
      • Chart.js
      • Circle Music Player
      • Draggable Elements
      • Dropzone
      • Facebook
      • Fitbit
      • Full Calendar
      • Google
      • Google Analytics
      • Google Optimize
      • Google Places
      • Ionic Elements
      • iTunes
      • Slidebar Menu
      • LinkedIn
      • Localize Translation
      • Mixpanel
      • Mouse & Keyboard Interactions
      • Multiselect Dropdown
      • Progress Bar
      • Rich Text Editor
      • Rich Text Editor (Legacy)
      • Screenshotlayer
      • SelectPDF
      • Slack
      • Segment
      • Slick Slideshow
      • SQL Database Connector
      • Star Rating
      • Stripe
      • Tinder-like Element
      • Twitter
      • YouTube
      • Zapier
    • Application Settings
      • App plan
      • General
      • Domain / email
      • Languages
      • SEO / metatags
      • API
      • Collaboration
      • Sub-apps
      • Versions
  • Account & Marketplace
    • Account and billing
      • Pricing and plans
        • Plans and billing
        • Billing cycle
        • FAQ: Pricing and Workload
      • Account Management
      • Building Apps for Others
      • Selling on the Marketplace
      • Plans & Billing (legacy)
    • Official Bubble Certification
      • Hiring certified developers
    • Building Plugins
      • The Plugin Editor
      • General Settings
      • Updating to Plugin API v4
      • Adding API Connections
      • Building Elements
      • Building Actions
      • Loading Data
      • Publishing and versioning
      • Github Integration
    • Building Templates
    • Application and data ownership
    • Marketplace policies
    • Bug reports
  • Vulnerability Disclosure Policy
  • Beta features
    • About the Beta features section
    • Native mobile apps 🔒
      • Introduction
        • What is a native mobile app?
        • Native mobile vs. web development
        • Differences in native and web elements
        • Native mobile app terminology
      • Building
        • Views and navigation
        • Native mobile actions
        • Components and gestures
        • Device resources
          • Location services
          • Camera/photo library
      • Previewing
      • Publishing
Powered by GitBook
On this page
  • Getting Started with Mobile App Publishing
  • Overview of the publishing process
  • Understanding deployment for Mobile
  • iOS vs. Android: Key Differences in Submission & Approval
  • Developer account requirements
  • Approval process: Apple vs. Google
  • Key compliance requirements
  • Understanding Builds, OTA Updates, and Live Versions for deployment
  • What is a Build?
  • How OTA (Over-the-Air) updates work
  • Differences between OTA updates and Builds
  • What is a Live version?
  • Operating system compatibility

Was this helpful?

  1. User manual
  2. Publishing your app

Native mobile app

Getting Started with Mobile App Publishing

Publishing a native mobile app is a bit different than publishing a web app. Deploying a web app through Bubble means clicking the Deploy button, while releasing a native mobile app requires additional steps involving third-party platforms: the Apple App Store and Google Play Store. Each store has its own setup processes, requirements, and guidelines that must be fulfilled independently of Bubble.

This guide covers each step you'll need to follow to successfully publish your native mobile app, including understanding essential terminology and navigating the approval processes for both the Apple App Store and Google Play Store.

Overview of the publishing process

Turning your Bubble app into a native mobile experience involves several key steps, from building your app with Mobile views, to the initial setup for the App Store and Google Play Store, testing and finally submitting for approval.

To begin, we will get familiar with the differences between distributing on the web vs mobile, and how mobile publishing works step by step. You will be going back and forth between your app, and your store(s) of choice throughout this process, so keep your tabs organized as you begin.

First, with Mobile development, it’s important to recognize that publishing is different from deploying.

Publishing your app involves several steps:

  1. Preparing necessary assets like icons, descriptions, screenshots, privacy policy, etc.

  2. Configuring your Bubble app for mobile deployment

  3. Registering developer accounts with Apple and or Google

  4. Deploying to the app stores

  5. Testing your build

  6. Submitting your app for review

  7. Publishing and making it available for users

Understanding deployment for Mobile

Deploying and publishing are often used interchangeably, but they have distinct meanings.

Traditionally, deploying in a web context means pushing updates live from your main branch, making them instantly available to users. In mobile, this concept applies less directly because updates often require a new build. A build is a packaged version of your app that is required for submission to the App Store or Google Play Store that we will learn more about soon.

Over-the-Air (OTA) updates allow you to make some changes without a full app store resubmission, though most updates still require a new build file that must be published to the App Store or Google Play.

In short, deployment in mobile development is preparing your app for release. True availability happens only after it’s published.

iOS vs. Android: Key Differences in Submission & Approval

When publishing a mobile app, it's important to be aware of the costs and differences between iOS and Android, especially regarding approval processes, developer accounts, and compliance requirements.

Developer account requirements

To publish an app, you must sign up for a developer account for each platform:

  • Apple Developer Program: Requires an annual fee of $99 and identity verification.

  • Google Play Console: Requires a one-time registration fee of $25.

Approval process: Apple vs. Google

Once signed up, and ready to submit, Apple and Google have distinct review and approval workflows:

  • Apple App Store: Stricter guidelines with a manual review process, leading to longer approval times (typically 1–3 days, but may take longer if revisions are required).

  • Google Play Store: Generally more lenient on design quality and content restrictions. Review includes both automated and manual steps, with approval timelines that are often similar to Apple’s.

Key compliance requirements

Both platforms enforce specific policies to ensure apps meet security and content guidelines:

  • Privacy Policy: A publicly accessible page detailing how user data is collected and used.

  • Permissions: Apps must justify the use of sensitive data (e.g., location, camera, contacts).

  • Content Guidelines: Apps must not include misleading content, harmful functionality, or policy violations.

By preparing for these requirements in advance, you can avoid common rejections, reduce delays, and ensure a smoother submission process.

Understanding Builds, OTA Updates, and Live Versions for deployment

Here’s a key glossary of concepts to understand before signing up for a developer account. Familiarizing yourself with these will give you a solid foundation in mobile development and help you navigate the publishing process when you're ready to launch your app on the app store.

What is a Build?

A build is a packaged version of your app that is required for submission to the App Store or Google Play Store.

Each build is assigned a version number, following a semantic format (e.g., 1.0.0 → 1.1.0 → 1.2.1).

Version Type
Example
Purpose
Requires App Store / Play Store Resubmission?

Major

1.0.0 → 2.0.0

Significant updates, breaking changes, or major new features

Yes

Minor

1.0.0 → 1.1.0

Smaller feature additions or improvements that maintain compatibility

Yes

Patch

1.0.0 → 1.0.1

Bug fixes, security updates, or minor tweaks

Yes

Key facts about builds:

  • Necessary for first-time app submission and for major updates.

  • Each build requires App Store & Play Store approval before going live.

  • Users must download a new build from the store to receive updates.

How OTA (Over-the-Air) updates work

OTA updates allow you to deliver changes to the latest live version of your app without submitting a new build to the app store. These updates function similarly to web app deployments—users will see the changes the next time they open the app.

To reiterate OTA updates only are sent to the latest built version, even if that built version is not in the app store.

Key facts about OTA updates:

  • Instant update: Users on the latest version get the update without needing to download anything and without the developer needing to submit a new version of the app.

    • Note: OTA updates, don’t have version numbers.

  • Great for bug fixes and content changes that don’t require new native functionality.

  • Unlimited OTA updates can be applied to the latest build.

  • No resubmission needed to the App Store or Google Play.

Differences between OTA updates and Builds

Feature
OTA Updates
Builds

Approval Needed

Typically deploys within 5-10 minutes

Yes (App Store / Play Store)

User Download Required

No

Yes

Use Case

Bug fixes, content tweaks, minor UI improvements

Major updates, new features, important security updates

Deprecation

Not automatically discontinued when multiple live versions are supported; must be deprecated manually

Older builds remain unless removed

What is a Live version?

A live version refers to the version of your app that users are currently running on their devices. Each live version is tied to a specific build (what’s installed from the App Store, Play Store, or distributed via testing tools like TestFlight), and is connected to a version of your app’s backend (the server-side logic and data).

Key things to know:

  • A live version is always tied to a specific build of your app.

  • OTA updates apply only to the latest built version, even if it hasn’t been submitted to the app store.

  • Users on older builds will not receive OTA updates unless they update to the latest build.

  • Bubble supports multiple live builds running simultaneously, which means users on older builds can continue using your app without breaking — but you’ll need to manually manage and deprecate older versions over time.

Managing version support & deprecation

Supporting multiple versions ensures a smooth user experience, as not all users update their apps immediately.

Why support multiple builds?

Supporting multiple builds ensures a smoother experience for your users — especially since not everyone updates their app right away. Bubble allows multiple live builds to run in parallel, giving you more flexibility and control over how and when users receive updates.

  • Users don’t update immediately: some users may stay on older builds for weeks (or longer), so it’s important that those builds continue to work correctly.

  • Testing before release: you may want to roll out and test a new build (via TestFlight or internal testing) before making it widely available in the App Store or Play Store.

  • OTA updates are build-specific: OTA updates only apply to the latest built version. If a user is on an older build, they won’t receive the update—so keeping older builds functional is essential.

  • Smoother user experience: requiring users to download a new version for every update can cause friction. Supporting multiple builds lets you avoid that for minor updates or bug fixes. App store delays: since store reviews can take time, keeping older builds live ensures your app remains usable while newer builds wait for approval.

Deprecation tip: While Bubble supports multiple live builds, older versions are not deprecated automatically. You’ll need to manually deprecate any versions you no longer want users to access.

Bubble’s Live version limits

Bubble limits the number of concurrent live versions you can support, meaning you must manage updates carefully.

Best practices for deprecating old builds

  • Encourage updates: Use in-app messaging or push notifications to inform users of new builds.

  • Gradually phase out older versions rather than forcing instant updates.

By understanding builds, OTA updates, and live version management, you can maintain a smooth deployment process and keep your app updated efficiently.

Now that you have a better understanding around Mobile publishing and deployment, it’s time to learn how to publish step by step to iOS and Android.

Operating system compatibility

Our current version of React Native will support:

  • iOS devices running version 13.4 and later

  • Android devices running version 6.0 and later.

Devices running unsupported OS versions are not guaranteed to work as expected.

Please be aware that certain native features may only be supported by later OS versions as well. The oldest supported version will be noted per feature in the documentation.

As we stay up to date with the latest versions, these versions are bound to change.

Last updated 1 month ago

Was this helpful?