Lovable vs Bolt.new: handing an AI-built app to developers starts with the repository and backend

Bolt’s direct import is a better fit when retaining an existing GitHub repository; Lovable offers more flexibility when AI changes must go through review on a separate branch. Neither code handoff amounts to a complete migration: databases, sign-in, secrets, and domains need separate acceptance checks.

Source: support.bolt.new
November 7, 2026
6 min

After a business team builds an app with sign-in and customer records in Lovable or Bolt.new, handing it to developers usually serves one of two goals: continuing to edit the code together, or moving production operations into company-controlled accounts as well. The deliverables differ. If an existing GitHub repository must be retained, Bolt offers a more direct import path. If the project starts in Lovable and the team requires AI changes to pass through a feature branch first, Lovable’s current branch synchronization is a better fit. Fully leaving platform hosting requires a separate handoff of the database, authentication, and runtime services.

An existing repository and an existing app are different starting points

Bolt’s GitHub documentation supports importing an existing nonempty repository, requiring push permission and a default branch. However, it also states that the project connects to main and cannot switch to another branch inside Bolt. Teams with an existing engineering repository must weigh convenient importing against this main-branch constraint.

Lovable’s Git sync creates a new repository on the first connection; it cannot directly attach an existing repository this way. That does not mean Lovable cannot accept an external app: its separate ZIP import reads existing code, rebuilds the app as a TanStack Start project, and moves the database and users into its built-in backend. This is an app migration, rather than continued synchronization of the original repository as it stands.

For example, if a company already has a customer portal and only wants business staff to edit the interface while developers maintain the original repository, evaluating Bolt first makes more sense. If the team accepts a rebuild and backend change, Lovable’s ZIP route is also an option, but data and users need separate exports. Passwords and existing sessions do not transfer through this import; users must verify their email and set a new password on their next sign-in. The cost of communicating this to users should not disappear behind the phrase “supports importing.”

Who can change which branch after the handoff?

Lovable pushes in-platform changes to the repository and pulls commits on the currently synchronized branch. It synchronizes one branch at a time and allows branches to be created or switched. If the company requires code review for every change, Lovable can work on a dedicated feature branch, with changes reaching the main branch through a pull request. Developers’ other branches do not automatically appear in Lovable until they merge into the synchronized branch or the synchronization target changes. This arrangement suits ongoing collaboration between business staff and engineers.

Bolt also provides two-way synchronization; its documentation says it checks GitHub for updates every 30 seconds, but the project remains on main. In a shared project, collaborators’ changes sync to GitHub only after the project owner opens the project. At handoff, the owner should therefore confirm that the repository contains the final round of changes and clarify the rules for writing to the main branch. “Two-way synchronization is enabled” cannot replace confirmation of branch rules and personal responsibilities.

Another easily missed boundary concerns Lovable’s database migration files and Edge Function code in the repository: syncing them back through Git does not automatically execute migrations or deploy functions. When developers return a feature that needs a new field, they should also explain the database change and function deployment, rather than submitting interface code alone. The official sync documentation explicitly distinguishes these actions.

Moving only frontend hosting versus handing over the backend

For Lovable, the external deployment guide allows the frontend to move first while retaining the built-in backend. This lets a team change its deployment pipeline without immediately moving customer data, although the app still uses the original services. Identify the project’s stack as well: new apps created from May 13, 2026 use TanStack Start and need a host capable of running server code; earlier React + Vite apps can build to static files. Packaging a newer project as a static website will not run its server-side features.

If the Lovable backend must also move, the official documentation provides a route to a Supabase project under your own account. Database records, storage files, authentication providers, secrets, functions, and scheduled jobs need separate handling; app connectors and AI calls also need checking for continued reliance on Lovable. When migrating out to Supabase, the database export includes users’ password hashes, allowing passwords to be retained after a correct restore, but not sign-in sessions. This direction differs from the ZIP import discussed earlier. Do not promise that users never need to sign in again, or assume every migration requires a password reset.

Bolt offers a way to claim an existing Bolt Database in Supabase, requiring Bolt Pro or Teams and an operator who owns the Supabase organization. To keep current data, distinguish Claim from Connect: the latter connects the project to a different database, and the documentation warns of possible data loss. Claiming into a Supabase Free account also disables leaked password protection; retaining that protection requires Supabase Pro or higher. These conditions affect handoff accounts and cost arrangements.

A Bolt database handoff does not complete runtime configuration on the new host for you. Its secrets documentation states that secrets are used by server functions and are not written into project files. After receiving the code, developers still need to determine where functions run, who manages external-service accounts, and how the target environment obtains the required secrets. Lovable’s external deployment guide likewise requires secrets to be configured separately at the destination. A repository alone cannot complete this handoff on either platform.

Accept the handoff through a business flow, not just the homepage

Define the customer-portal handoff as a reproducible acceptance check: a developer deploys the agreed commit to the target host, signs in with a test account, creates a test customer record, uploads an attachment, and triggers an email or another service call the app actually uses. This is a proposed acceptance scenario, not a test result for either tool. For every step, record whether it reaches the old or new backend. In particular, changing a code branch should not be mistaken for obtaining an independent test database.

Schedule the domain change separately too. Lovable’s external deployment guide requires pointing the custom domain to the new host and updating authentication’s allowed redirect URLs. Bolt’s domain documentation likewise treats domain connection, DNS, and certificate configuration as separate steps. Acceptance should include the sign-in redirect at the new address, rather than merely checking that the homepage opens. If a service callback address changes, update the corresponding external service’s configuration as well.

The final choice depends on the handoff model. If you are keeping an existing GitHub repository and can accept working on main, evaluate Bolt first. If you are starting from a Lovable project and need AI changes reviewed on a separate branch, you can continue using Lovable’s two-way sync. If the goal is to leave the original platform completely, first have developers list and verify the remaining backend calls and account ownership, then decide on a cutover date. Exportable code provides the starting point; the handoff is complete when the receiving team can maintain production services independently.

Content note:This article is based on publicly available information and is intended as a reference for evaluating tools. Features, pricing, and related policies may change at any time; please refer to the latest official information.

Original source:support.bolt.new