How to turn your Lovable app into a real mobile app (and get it into the App Store)

So you built your app in Lovable, published it, and it works. Now you want it on people’s phones — a real app in the App Store and Google Play, with an icon on the home screen and notifications that buzz.

This is where people hit a wall. Mobile apps need builds, signing certificates, permission strings, push keys and distribution profiles, and Lovable by itself isn’t equipped to handle any of them. Here’s how getting past it works, what your options are, and where people get stuck.

Can you publish a Lovable app to the App Store?

Not directly. Lovable builds web apps: websites that behave like apps in a browser. The App Store and Google Play want native apps — software built for iOS and Android, signed with your developer certificates, and reviewed by Apple and Google before anyone can install it.

There’s no “export to App Store” button, and there isn’t going to be one, because the gap isn’t a missing feature. It’s a different kind of software. The good news is that the gap is much smaller than it looks.

What Lovable actually is under the hood

It’s easy to think of Lovable as a magic service that conjures apps out of thin air. Under the hood, it’s built from well-known parts:

• The front end is React, the most popular way of building web apps there is.
• The backend is Supabase — Lovable Cloud runs on it. That’s your database, your user accounts and your file storage.
• AI ties them together, writing the code as you describe what you want.

That matters, because it means nothing in your Lovable app is locked in a format only Lovable understands. It’s ordinary code. And the mobile framework I recommend, React Native, is built on React — so an AI coding agent that can read your Lovable app can rebuild it for phones without starting from zero.

Your three options for getting a Lovable app onto phones

Whichever route you take, the stores charge the same: Apple $99 a year, Google Play $25 once.

Why I don’t recommend wrapping your Lovable app

If you Google “Lovable to mobile app”, most of what comes back is a wrapper. The pitch is appealing: no second codebase — take the website you already have, put it inside a native shell, and ship that.

Two problems. First, Apple is strict about this. Their review guidelines say an app needs features and an interface that “elevate it beyond a repackaged website”, and wrapped web apps get rejected under exactly that rule. Mobile apps need to feel like mobile apps.

Second, everything native becomes a workaround. Push notifications, haptics, location, widgets, Google and Apple sign-in — wrappers can reach all of it, but through plugins, bridges and often another paid service, each one a new thing to break. You’ve taken a website and you’re teaching it, one plugin at a time, to pretend to be a phone app.

Expo is the other way round: a long-established, free and open-source framework for building real mobile apps, with a huge ecosystem of first-class libraries. It also handles a lot of the miserable deployment work — builds, signing certificates, provisioning profiles and store submission.

Step 1: Get your code out of Lovable

This is the “eject”, and it’s less dramatic than it sounds. Lovable connects to GitHub, and the sync works both ways: everything you build in Lovable is committed to a repository you own, and anything pushed to that repository shows up back in Lovable.

1. In your Lovable project, connect GitHub. Lovable creates the repository for you.
2. Clone that repository onto your computer — or just ask your AI coding agent to do it.
3. Open the folder with an AI coding agent. I use Claude Code inside VS Code, but Cursor, Codex or the Claude desktop app all do the job.

You haven’t left Lovable by doing this. You can keep editing the web app there, or fix a bug locally and push it back up, and Lovable keeps deploying it. If you’d rather host the web app yourself, Netlify, Vercel and Cloudflare Pages will all do it for free.

Once the code’s on your machine, this prompt gets it running so you can see it’s the same app:

This folder is a web app I built in Lovable and cloned from GitHub. I'm not a developer, so explain anything you need me to do in plain English.

1. Read the project and tell me in a few sentences what it is: the framework, how it talks to its backend, and where the backend settings live (a .env file or src/integrations/supabase/client.ts).
2. Install what it needs and start it locally, then give me the address to open in my browser.
3. Check that it's talking to the same backend as the live Lovable app — the same sign-in and the same data.
4. Don't change any code, don't commit anything, and never print secret keys in full.

If anything fails, stop, show me the error, and tell me what you think it means before trying a fix.

Step 2: Build the mobile app beside it

Now the interesting part. With the web app’s code on your machine, the AI agent can create a new React Native app with Expo right next to it, and rebuild each screen for a phone: the sidebar becomes tabs, dialogs become bottom sheets, tables become cards, and it gets native extras the web app never could, like a barcode scanner that uses the phone’s camera.

The mobile app plugs into the same backend Lovable already manages. The credentials are already in the code you downloaded, so there’s nothing new to set up: same database, same tables, same user accounts. Someone who signed up on your website signs in on their phone with the same email and password.

I’ve written the full prompt for this — it’s long, because it’s careful about the details that break: it reads the web app before writing anything, keeps every table name byte-identical, never touches the web app’s files, and writes you a report of every screen it ported. Get the Lovable to React Native prompt →

Then you look at it on your phone, and you iterate the way you did in Lovable. Text cut off at the top of a screen? Tell the agent — attach a screenshot if it helps — and it fixes it.

Here’s the whole thing on video, start to finish:

Step 3: Get it onto your phone and into the stores

This is the part Lovable could never do, and the part Expo is best at. Once you’re happy with the app, one command — npx testflight — builds it in the cloud and sends it to Apple’s TestFlight. Expo takes care of the app identifiers, provisioning profiles, distribution certificates and push notification keys, and even creates the listing in App Store Connect, ready for you to fill in and submit. Android goes the same way.

Three things to know before you get there:

• Apple’s developer account is $99 a year, and you need it early — not just to publish, but to install your own app on a real iPhone. Verification can take a few days, so start it now.
• Google Play is $25 once, but new personal accounts have to run a closed test with a group of testers for two weeks before they’re allowed into production. Start that early too.
• You don’t need a Mac. Expo builds iOS apps in the cloud. A Mac only adds the iPhone simulator.

Should you stay on Lovable’s backend?

To start with, yes. Keeping Lovable’s backend is what makes this route quick: your users and data are already there, and the mobile app just connects to them.

But you’ll hit its limits on mobile sooner than on the web. On Lovable Cloud you don’t get the full Supabase dashboard, and some of the settings a native app needs live there — native Google and Apple sign-in, and the links that bounce a user from an email back into your app. That’s why my prompt builds the mobile app with email-and-password sign-in only: it’s the one method that needs no dashboard access at all.

When you outgrow that, the full eject is moving your backend to a Supabase project you own. It’s a real job, not a button — Lovable’s own documentation says there’s no one-click migration. Roughly:

1. Export your data. Lovable Cloud has a database export in its advanced settings. Download your storage files separately.
2. Create your own Supabase project and restore the database into it.
3. Redo what doesn’t come across in the export: storage files, edge functions, their secrets and API keys, and your sign-in settings.
4. Point both apps at the new project — the web app and the mobile app — at the same moment, so nobody’s writing to the old database while you move.

Get the order wrong and you can lose data or lock users out, so plan it before you touch anything. This prompt reads your project and writes the plan:

I want to move this app off Lovable Cloud onto a Supabase project I own, and I need to know what that involves before I start. Don't change anything — just read the project and report.

1. List every database table the app uses, and any views or database functions it calls.
2. List every storage bucket and what kind of files go in it.
3. List every edge function (in supabase/functions), what it does, and every secret or API key it expects.
4. Tell me how users sign in today (email and password, magic link, Google, anything else) and what will need setting up again on a new project.
5. Find every place the Supabase URL and key are set — in the web app and in any mobile app in this folder.
6. Give me a checklist for the move, in order, and flag every step where I could lose data or lock users out.

Plain English, please — I'm not a developer.

My advice: get the mobile app working and into TestFlight on Lovable’s backend first. Move the backend when you have a reason to — native sign-in, more control, or simply not wanting your app to depend on a builder you’ve outgrown.

How long does it take, and what does it cost?

If your Lovable app is a handful of screens, the mobile rebuild itself can be a matter of days. The calendar time goes on everything around it: Apple’s account verification, Google’s two-week test, and the first round of store review.

The money is small. The store fees, an AI coding agent from about $20 a month, and Expo’s free tier, which comfortably covers a small app’s builds. You can keep paying for Lovable while you still use it for the web app, or drop it once you don’t. I’ve broken down every cost in detail in how much it costs to build a mobile app.