This section describes previewing mobile apps. If you're looking for documentation on previewing web apps, see the article below:
Article: Previewing a web app
BubbleGo is deprecated. BubbleGo was previously the recommended way to preview native mobile apps on a device, but it's no longer updated. It doesn't reflect features added to Bubble since then, so what you see in BubbleGo may not match how your app looks and works on real devices. To preview reliably, use simulated device or a dev build instead.
Previewing your app works much like the Bubble web app editor, letting you see and test changes as you make them. Keep in mind that some parts of the native mobile app editor rely on built-in features of mobile devices, which can vary between iOS and Android. As a result, not every element displays accurately in web preview. Simulated device closes most of that gap.
There are five ways to preview your app:
Method | Where it runs | Plugins | What you need | Best for |
Your browser, in the editor | Shows a "can't render this" message | Nothing | Quick iteration on layout and logic | |
Your browser, on a separate page | Shows a "can't render this" message | Nothing | Quick iteration on layout and logic | |
Your browser, on a simulated device | All, including those with third-party native libraries | Nothing | Checking native elements and plugin behavior without a device | |
BubbleGo | Your device, in the BubbleGo app | React Native and a few third-party libraries already installed by Bubble | The BubbleGo app | Getting a feel for the app on a device |
Your device, as your own app | All, including those with third-party native libraries | An App Store and Google Play connection | Testing native features like push notifications and deep linking |
Preview mode runs inside the editor, while web preview opens on a separate page in a new browser tab. To switch to simulated device, open preview mode and use the Web Preview dropdown in the top-left corner of the preview.
Preview mode
You can preview your mobile app without leaving the editor. Instead of opening a separate preview, your app loads right where you're working, inside a frame that matches the size of the phone you choose. You can check a change and get back to building in a few clicks.
Opening preview mode
Open the view you want to preview. Use the view (see Key terms) dropdown in the top bar to open the view you want to test.
Click the play icon. Click the play icon at the top of the left-hand toolbar. Your view loads in the editor, and you can tap, type, and run workflows just as your users would.
Preview mode loads your view in a phone-sized frame inside the editor.
Go back to editing. When you're done, click one of the other icons in the left-hand toolbar, such as the Design tab, to go back to building.
Choosing a device
Your app can look different on different phones, so the top bar lets you choose which device to preview on:
Setting | What it does |
Device | Choose a phone model, such as an iPhone or an Android device, to preview your app at that phone's screen size. |
Screen size | Shows the width and height of the selected device in pixels. These update when you pick a different device. |
Show device frame | Click the phone icon to show or hide a frame around the preview, including the device's outline and status bar. |
Zoom | Zoom the preview in or out, which is useful for seeing the whole screen at once or checking small details. |
We recommend checking your app on a few different devices, especially a small and a large one, to make sure your layout works across screen sizes.
Previewing as a specific user
Many apps look and behave differently depending on who's logged in. An admin may see views that regular users can't, and each user sees their own data. With Preview as, you can run your app as a specific user from your database, and check what they see without logging in and out yourself.
Open the Preview as dropdown. In preview mode, click the Preview as dropdown in the top bar.
Select a user.
The Preview as dropdown lists the users in your database, along with a logged-out user.
Select the user you want to preview as. The preview reloads, and your app now runs as if that user were logged in.
Switch between users. To compare how your app works for different users, select another user from the dropdown. You can switch as often as you need while you test.
Previewing as a user follows that user's permissions, including your privacy rules (see Key terms). That makes it a quick way to check that each user only sees the data they're supposed to.
The preview runs your app for real. If you save a form, delete a record, or run any other workflow while previewing as a user, the change is made in your database as if that user had done it.
What preview mode can't show
Preview mode runs your app in the browser, so some native features of iOS and Android, like the device camera, push notifications, and plugins that rely on their own native libraries (see Key terms), don't work the way they will on a phone. To test those, use simulated device or a dev build.
Web preview
Web preview opens your app on a separate page in a new browser tab. To open it, click the new tab icon in the top-right corner of the editor.
Differences from web app preview
Web preview works mostly like the preview in the Bubble web app editor, with a few key differences:
There's no update banner (see Key terms) in the preview when changes have been made to the app
There's an extended bar for managing how the app will look across different devices (see below)
Web preview limitations
Web preview has a few limitations:
Native maps element won't render: Use simulated device
Native datetime picker won't render: Use simulated device
Plugins with their own third-party native libraries won't load: Use simulated device
Permissions request workflows may not work properly: Use simulated device
Camera workflows won't work properly: Use a dev build
Push notifications can't be sent to web preview: Use a dev build
Multi-line inputs in floating groups won't expand to fit height (see Key terms)
Device emulator bar
The bar at the top of the screen lets you emulate how the app will look on different devices, screen sizes, and with a specific zoom level.
Show device frame: Shows or hides the frame of the selected device (the frame, buttons, and notch, camera, or sensors of the device selected in setting 2).
Select device: Provides a list of widely used devices to emulate how the app will look and behave on that specific device.
Screen size (px): The actual screen size of the selected device. This is a locked field and updates according to the device selected in setting 2.
Zoom level: Zooms the emulator to a specific percentage or to fit the screen height. This zoom affects the entire emulated device, not just the screen.
We recommend testing your app across all devices, so it looks and works the way you expect everywhere.
Simulated device
Simulated device runs your app on a simulated iOS or Android device, streamed into your browser. Unlike web preview, which renders your app in the browser, the simulator runs a real build of your app, so native elements and plugins that rely on their own third-party native libraries work the way they will on a device.
Use simulated device to check anything web preview can't render, without needing a physical device or an App Store or Google Play connection.
Web preview is still the fastest way to iterate on layout and logic, and it's the only place you can inspect and debug (see Key terms). Switch to simulated device when you need to confirm that native behavior is correct.
Switching to simulated device
Open preview mode. Click the play icon at the top of the left-hand toolbar.
Open the Web Preview dropdown. In the top-left corner of the preview, open the Web Preview dropdown.
The Web Preview dropdown in the top-left corner of preview mode.
Select Simulated device. Choose Simulated device. If your app has plugins that need a real build, Bubble also prompts you in web preview with a tooltip.
Simulated device limitations
The simulator runs a real build of your app, but it runs it in the cloud, so anything that depends on physical hardware won't work:
Camera workflows won't work properly: Use a dev build
Push notifications can't be sent to the simulator: Use a dev build
Device sensors won't report real data: Use a dev build
Inspect and debug aren't available in simulated device: Use web preview
When you need a new build
Most changes reach the simulator instantly, but some are baked into the build itself:
Adding or updating plugins that use third-party native libraries
Changing native device permissions
Bubble updates to its internal mobile engine
When one of these happens, a Rebuild button appears in the top-right corner of the simulator, along with a message telling you which change caused it: that you added a plugin since the last build, that you changed a setting that affects native configuration, or that Bubble made an update.
Click Rebuild to start the build. Building can take up to 10 minutes, and you can keep working in the editor while it runs. The button shows Building while the build is in progress, and Up to date once you're on the latest build. Until the rebuild finishes, the simulator keeps running the previous build, so what you see may not match your current settings.
If you don't see a Rebuild button, your simulator is already running the current build.
Testing on your own device
The simulator includes a Test on your own device panel, which is your path from previewing in the browser to testing on real hardware. From here you can create a dev build, or connect your app to App Store Connect and Google Play if you haven't yet.
Use this when you've confirmed native behavior in the simulator and want to try your app on a physical device through a dev build.
BubbleGo
BubbleGo is deprecated. BubbleGo was previously the recommended way to preview native mobile apps on a device, but it's no longer updated. It doesn't reflect features added to Bubble since then, so what you see in BubbleGo may not match how your app looks and works on real devices. To preview reliably, use simulated device or a dev build instead.
BubbleGo was a native mobile app that let you load and interact with your mobile app directly on your device. This mimicked the experience of having the app installed on your phone, without needing to connect your project or publish it to the app stores.
Dev build
A dev build is a version of your native mobile app that you install on your own device for testing. It looks and behaves like your real app, with your icon, your branding, and your plugins, but it stays synced with the Bubble editor, so changes appear on your phone right away. This lets you test your app the way your users will experience it, without publishing to the app stores.
Because a dev build is compiled from your app specifically, it also uses your app's own URL scheme for deep linking and universal links (see Key terms), and runs against your app's real push notification configuration.
Dev builds vs. production builds
A production build is pinned to one version of your app. To ship changes, you create a new build and release it through the app stores. A dev build works differently: it stays synced with the editor, so you rarely need a new one. Create it once, install it on your device, and keep testing as your app evolves.
Dev builds use the same bundle ID and package name as your production app, so push notifications and plugins run against your app's real configuration. This also means your dev build appears alongside production builds in TestFlight (see Key terms) or the Google Play Console. To help you tell them apart, a dev build has a modified app icon and launch screen.
Feature | Dev build | Production build |
App version | Any of your development branches | Pinned to a single version |
Getting changes live | Appears as you edit, shake to refresh | Requires a new build and app store release |
Bundle ID or package name | Your app's production identifiers | Your app's production identifiers |
Icon and launch screen | Modified, so you can tell it apart | Your production branding |
Example icon |
Creating a dev build
Creating a dev build requires your app to be connected to the App Store and Google Play Store, since the build is delivered through TestFlight and the Google Play Console. If you haven't set this up yet, see iOS App Store and Google Play Store.
Dev builds are created per app.
Open the build manager. In the Settings tab, open Manage builds and live versions.
Start a new dev build.
The + Dev build button on the Manage builds and live versions page.
Click + Dev build in the top-right corner.
Confirm and build. In the modal, add an optional description, confirm the version, and click Build.
Building can take up to 15 minutes. You can track the status on the same page where your builds and live versions are managed, and we'll email you when the build is ready. From there, install it on your device the same way you install a regular test build:
Platform | How to install |
iOS | Through TestFlight |
Android | Through the Google Play Console. You'll need to manually release the build to an internal testing track. |
TestFlight builds expire 90 days after they're uploaded. If your dev build expires, create a new one.
Testing with a dev build
Open the dev build. Open the dev build on your device. The launch screen shows your app's name with a Dev build tag.
Log in. Log in with your Bubble account credentials.
Select a branch.
The branch selection screen lists the branches you can load in your dev build.
Select the branch (see Key terms) you want to test. It loads immediately.
Refresh to see updates. Shake your device to refresh and view new updates.
Your dev build now loads your app as it exists in the editor for that branch. Changes you make in the editor become available in the dev build without a new deployment. Shake your device to refresh the app or return to the launch screen, for example to reload from scratch or switch to a different branch.
When you need a new dev build
Most changes reach your dev build instantly, but some are baked into the native binary itself and can only be delivered by creating a new build. This includes:
Adding or updating plugins that use third-party native libraries
Changing native device permissions
Bubble updates to its internal mobile engine
When this happens, the affected dev build is marked Outdated in Manage builds and live versions. An outdated dev build still receives your changes, but it won't reflect the ones listed above until you create a new build.
To help you keep track of what each build contains, every build card in Manage builds and live versions lists the plugins that were included when the build was created. Inside the dev build itself, branches that contain changes requiring a new build are flagged on the branch selection screen.
The same changes require a new build in simulated device, where Bubble prompts you with a Rebuild button when one is needed.
Each build card shows the build's tags and the plugins it includes.
FAQ: Previewing a mobile app
What are the ways to preview a mobile app?
What are the ways to preview a mobile app?
There are five: preview mode (in a phone-sized frame inside the editor), web preview (on a separate page, in a new browser tab), simulated device (a real build of your app on a simulated device, in the browser), BubbleGo (deprecated, your app loaded on your own device through Bubble's BubbleGo app), and dev builds (a synced version of your app installed on your device).
Which preview method should I use?
Which preview method should I use?
Use web preview for quick iteration on layout and logic, since it's the fastest option and the only place you can inspect and debug. Switch to simulated device to confirm native behavior without needing a physical device. Use a dev build to test native features like push notifications and deep linking.
Why doesn't everything display correctly in web preview?
Why doesn't everything display correctly in web preview?
Some parts of the native mobile app editor rely on built-in features of mobile devices, which vary between iOS and Android, so not every element renders accurately in web preview. Simulated device closes most of that gap.
What are the limitations of web preview?
What are the limitations of web preview?
The native maps element and native datetime picker won't render, plugins with their own third-party native libraries won't load, permissions request workflows may not work properly, camera workflows won't work properly, push notifications can't be sent to web preview, and multi-line inputs in floating groups won't expand to fit their height.
How is simulated device different from web preview?
How is simulated device different from web preview?
Web preview renders your app in the browser, while simulated device runs a real build of your app on a simulated iOS or Android device, streamed into your browser. Because it's a real build, native elements and plugins that rely on their own third-party native libraries work the way they will on a device.
Do I need a device or an app store account to use simulated device?
Do I need a device or an app store account to use simulated device?
No. Simulated device lets you check anything web preview can't render without a physical device or an App Store or Google Play connection.
What are the limitations of simulated device?
What are the limitations of simulated device?
The simulator runs a real build, but it runs it in the cloud, so anything depending on physical hardware won't work: camera workflows won't work properly, push notifications can't be sent to the simulator, and device sensors won't report real data. To test these, use a dev build. Inspect and debug also aren't available in simulated device, so use web preview for those.
When does simulated device need a rebuild?
When does simulated device need a rebuild?
Most changes reach the simulator instantly, but some are baked into the build itself. When that happens, a Rebuild button appears in the top-right corner of the simulator. Building can take up to 10 minutes, and you can keep working in the editor while it runs. Until the rebuild finishes, the simulator keeps running the previous build, so what you see may not match your current settings.
Could BubbleGo send push notifications or run any plugin?
Could BubbleGo send push notifications or run any plugin?
No. BubbleGo couldn't send push notifications, and it couldn't run plugins that rely on their own third-party native libraries. To test those plugins, use simulated device or a dev build. To test push notifications, use a dev build.
How did refreshing work in BubbleGo?
How did refreshing work in BubbleGo?
In BubbleGo for iOS, you could refresh your app by shaking your iPhone.
What is a dev build?
What is a dev build?
A dev build is a version of your native mobile app that you install on your own device for testing. It looks and behaves like your real app, with your icon, branding, and plugins, but it stays synced with the Bubble editor, so changes appear on your phone right away, without publishing to the app stores.
What do I need before creating a dev build?
What do I need before creating a dev build?
Your app needs to be connected to the App Store and Google Play Store, since the build is delivered through TestFlight and the Google Play Console.
How long does a dev build take, and how do I install it?
How long does a dev build take, and how do I install it?
Building can take up to 15 minutes, and Bubble emails you when it's ready. On iOS you install it through TestFlight, and on Android through the Google Play Console, where you'll need to manually release the build to an internal testing track.
Do dev builds expire?
Do dev builds expire?
Yes. TestFlight builds expire 90 days after they're uploaded. If your dev build expires, create a new one.
How do I see my latest editor changes in a dev build?
How do I see my latest editor changes in a dev build?
Your dev build loads your app as it exists in the editor for the branch you select, and changes you make in the editor become available without a new deployment. Shake your device to refresh the app or return to the launch screen, for example to reload from scratch or switch branches.
When does a dev build need to be rebuilt?
When does a dev build need to be rebuilt?
Most changes reach your dev build instantly, but some are baked into the native binary and need a new build: adding or updating plugins that use third-party native libraries, changing native device permissions, and Bubble updates to its internal mobile engine. When this happens, the build is marked Outdated in Manage builds and live versions. It still receives your other changes, but won't reflect those three until you create a new build.
Key terms
View: A view is a screen in a native mobile app, similar to a page in a web app.
Article: Mobile: The view element
Privacy rules: Privacy rules are conditions you set up on a data type to control who can find, view, and change its data.
Article: Protecting data with privacy rules
Push notifications: Push notifications are messages sent to a user's device, even when your app isn't open.
Article: Actions
Native library: A native library is code written for iOS or Android that gives a plugin access to features of the device. Plugins that include one need a real build of your app to run.
Update banner: Like the We just updated the page banner in the web app editor preview.
Floating group: A floating group stays fixed on the screen while the rest of the view scrolls.
Article: Mobile: Floating group element
Inspect and debug: The native mobile debugger lets you inspect elements and follow your workflows while your app runs.
Article: The native mobile debugger
URL scheme: A URL scheme is a custom prefix, such as myapp://, that opens your app from a link.
Article: Native mobile app terminology
Deep link: A deep link opens your app on a specific view.
Article: Actions
Universal link: A universal link is a standard https:// link on your app's domain that opens your installed app.
Article: Global native mobile settings
Bundle ID and package name: A bundle ID (iOS) or package name (Android) is the unique identifier for your app in the app stores.
TestFlight: TestFlight is Apple's service for testing an app before you release it on the App Store.
Article: iOS App Store
Branch: A branch is a separate version of your app where you can work on changes without affecting other versions.
Article: How version control works in Bubble









