At some point, many AI-built apps outgrow the builder. You need a native feature it can't produce, a bug it keeps reintroducing, or a security review before you take payments. That's when ownership matters: can you get your code out, run it somewhere else and hand it to a developer?
Here's how to do that cleanly, step by step.
Step 1: Find out what you can actually export
Builders handle export differently, and the details change often, so check your current plan:
- GitHub sync. Many builders, including Lovable, Bolt and Rork, can push your project to a GitHub repository, often with two-way sync. This is the best option because you get history, not just a snapshot.
- ZIP download. Some builders, such as RapidNative, let you download the full project as an archive.
- No export, or export only on higher tiers. If you can't get a standard project out, you don't own the app. Decide that before you invest more time.
Also check what kind of project you're getting:
| Builder output | What it is | Path to the app stores |
|---|---|---|
| Expo React Native project (Rork, RapidNative and other mobile-first builders) | A real cross-platform mobile app | Build with EAS and submit, after hardening |
| Web app (Lovable and other web-first builders) | A React web app, often Vite plus Supabase | Rebuild the client in Expo, or wrap it and risk rejection |
A wrapped web app is the fastest path to a store listing and the most likely to be rejected for minimum functionality. See why AI-built apps get rejected.
Step 2: Make it run outside the platform
An export that only works inside the builder isn't portable yet. Clone or unzip it and try a clean run:
npm install
npx expo-doctor@latest
npx expo start
Common problems at this step:
- Missing environment variables. The builder injected keys you never saw. Make a list of everything the app needs.
- Platform-only packages. Some exports depend on the builder's own SDK, hosting or preview tools. These need replacing with standard equivalents.
- Outdated dependencies. Exports can lag behind the current Expo SDK. Running
npx expo install --fixaligns versions, and a full SDK upgrade may come next (SDK 58 notes).
If it builds and runs on a real device with a development build, you have a portable app.
Step 3: Take ownership of everything around the code
The code is only part of the app. Make sure your company owns:
- The backend project. If the builder created a Supabase or Firebase project for you, find out whose account it lives in and transfer it to your organization.
- Authentication providers. Google, Apple and other OAuth clients should be registered under your developer accounts, with redirect URLs that don't point at the builder's domain.
- Store accounts. Apple Developer and Google Play Console in your company's name. Organization accounts on Apple need a D-U-N-S number.
- Expo account. Create an organization and move the project into it, so builds, updates and credentials belong to you.
- Domains, email sending and analytics.
Step 4: Rotate every secret
Assume any key that passed through the builder or sat in the exported code is exposed: database service keys, AI provider keys, payment keys and email API keys. Generate new ones, store them on a server or in EAS environment variables as appropriate, and remove secrets from the client entirely. Our AI-built app security checklist explains which keys can live in the app and which never should.
Step 5: Pick one source of truth
If your builder syncs both ways with GitHub, edits from both sides can collide, and some builders keep their own version when both change at once. Once a developer starts working in the repository:
- Stop editing the main branch in the builder, or
- Use the builder only on a separate branch for prototyping new screens, and let the developer merge what's useful.
Step 6: Write a handoff package
A developer can start faster, and quote more accurately, with:
- Repository access and a note on how you've been running it
- A list of environment variables, with values shared securely and never by email
- Every account involved: backend, auth, payments, analytics, stores
- What works, what's broken and what's missing, in plain language
- The next three things you need, whether that's payments, offline mode or a store launch
- Your prompt history, if the builder keeps one, which often explains why things are the way they are
What a developer will do next
A sensible takeover follows a predictable path:
- Audit. Read the code, run it, and check data access rules, secrets, payments, dependencies and store readiness.
- Decide what stays. Most UI and screens usually survive. Data access, state management and native configuration often get rewritten.
- Harden. Fix Supabase RLS, move secrets and payment checks to the server, add crash reporting and set up EAS Build, Submit and Update.
- Ship and maintain. Submit to the stores, then keep up with yearly requirements like iOS 27's scene lifecycle and Google Play's API 36 target.
If the export is messy, a developer may suggest moving your screens onto a clean foundation, such as a production Expo template, rather than untangling generated code line by line. That's often faster than it sounds, because the auth, navigation and settings scaffolding is already done.
Is it time?
If you're not sure whether to keep building in the builder or bring in a developer, our guide to vibe coding vs hiring a developer lists the nine signs. For the full cost picture, see the 3-year breakdown of hiring a React Native developer vs an AI app builder.