Learn how to use Thunkable's live companion app to preview and test your project on an actual iPhone as you build — the fastest feedback loop in no-code iOS development.
Testing on a real iPhone early and often is the difference between a smooth build and a frustrating one.
The simulator-style preview inside the Thunkable web editor is convenient, but it can't fully reproduce how components behave on real hardware — touch responsiveness, camera access, GPS, and screen sizing all differ on a physical device.
Thunkable's live companion app closes that gap. It mirrors your project onto your iPhone and updates as you edit, so you catch layout and behavior problems immediately.
For a no-code builder whose whole value is speed, this tight feedback loop is one of the biggest productivity wins available.
This guide walks through setting it up and using it effectively, plus what live preview can and can't tell you before you publish.
On your iPhone, open the App Store and search for Thunkable's official live or companion app. Install it like any other app.
Use the same Apple region account you normally use; the companion app is a free download.
When you first open it, it may ask for permissions such as camera, location, or notifications. Grant the ones relevant to what you're building, since the app needs them to preview those features accurately.
Make sure your iOS version is reasonably current. Very old iOS versions can cause the companion app to behave unpredictably.
With the app installed, you have the on-device half of the live-preview loop ready.
Live preview works best when your development computer and your iPhone are on the same Wi-Fi network.
Connect both devices to the same network before you start. Mismatched networks — for example, your laptop on Wi-Fi and your phone on cellular — are the single most common reason live preview fails to connect.
Avoid restrictive networks. Corporate, school, and public Wi-Fi often block the device-to-device communication that live preview relies on.
If you're on such a network, a personal hotspot or a home network usually resolves connection problems instantly.
Getting the network right up front saves you from chasing phantom bugs that are really just connectivity issues.
In the Thunkable web editor, open the project you want to test and find the live or preview option, typically shown as a way to test on your device.
Thunkable will present a QR code or a connection prompt. Open the companion app on your iPhone and scan the code, or sign in with the same account to see your projects listed.
Within a moment, your app should launch inside the companion app on your phone.
If it doesn't connect, re-check the network step first, then confirm you're signed into the same account on both the editor and the app.
Once connected, you'll see your actual screens running on real hardware.
Now exercise your app the way a real user would.
Tap through every screen and navigation path. Watch for layout that looks fine in the browser preview but breaks on the iPhone's real dimensions or notch and safe-area.
Test device-specific components directly: take a photo with the camera component, trigger location, and confirm any sensors respond.
Enter real data into forms and confirm it saves and retrieves correctly from your connected data source or API.
As you edit blocks and design in the web editor, the companion app reflects changes quickly, letting you fix and re-test in seconds.
This rapid on-device iteration is where Thunkable's live preview genuinely shines.
Live preview is powerful, but it is not the same as a final published build, and confusing the two leads to surprises.
The companion app runs your project inside Thunkable's preview host. Some behaviors — push notification delivery, in-app purchases, certain background tasks, and final performance — only fully behave in a real installed build, not the live preview.
App icons, splash screens, and launch behavior also won't be represented by the companion app the way they will in the published app.
So treat live preview as your fast day-to-day loop, and always do a final round of testing on an actual installed build before submitting to the App Store.
That two-stage approach catches issues live preview structurally can't.
If live preview won't connect, work through the usual suspects in order.
Confirm both devices share the same Wi-Fi network and that it isn't a restrictive corporate or public network. Switching to a personal hotspot resolves a large share of cases.
Make sure the companion app and your account are the same on both ends, and that you're viewing the correct project.
Force-quit and reopen the companion app if it hangs, and refresh the editor.
Check that the companion app is updated to its latest version, since an outdated app can fail against newer editor features.
If a specific feature works in the browser preview but not on device, it's usually a permission the phone hasn't granted — check iOS Settings for the companion app.
A few habits make live testing far more productive.
Test on more than one device size if you can. An app that looks perfect on your phone may crowd on a smaller screen or stretch on a larger one.
Test under realistic conditions, including slower networks, so you see how your app behaves when API calls are slow.
Keep a short checklist of critical user journeys and run through them after every significant change, rather than only testing the screen you just edited.
Involve a non-technical tester. They'll tap things you never would and expose confusing flows.
Build these habits early and your eventual App Store submission will hit far fewer surprises.
Live preview is your fast daily loop, but it should never be your only test before submitting.
When the app feels finished, do a final round of testing on an actual installed build — the same kind of build you'll submit to Apple. This is the only way to see icons, splash screens, launch behavior, and true performance exactly as users will.
It's also where features that live preview can't fully exercise — push notifications, in-app purchases, and certain background tasks — finally behave the way they will in production.
Treat this as a distinct, deliberate phase. Walk through your critical user journeys again on the installed build, on a real network, before you ever open App Store Connect.
That two-stage rhythm — rapid iteration in live preview, then a thorough pass on a real build — catches the issues that would otherwise turn into an App Store rejection or a bad first review.
Yes, the live companion app is a free download from the App Store. It lets you preview your project on a real iPhone while you build in the web editor.
The most common cause is that your computer and iPhone are on different networks, or a restrictive corporate or public Wi-Fi is blocking the connection. Put both on the same network or use a personal hotspot.
No. Features like push notifications, in-app purchases, launch screens, and final performance behave fully only in an installed, published build. Always do a final test on a real build before submitting.
No. Live preview only requires the free companion app. You need the Apple Developer Program only when you're ready to build and publish to the App Store.