Insights / October 24, 2026

Hiring a Lovable developer without breaking your app

Yes, a developer can work on your Lovable app while you keep using Lovable, and nothing has to break. It works when the developer works through GitHub instead of around Lovable, and follows a few rules about branches, publishing and the database. Without those rules, you and the developer will overwrite each other’s work.

We work this way every day. We’re the engineering team for a media delivery app that its non-technical founder built in Lovable, with an iOS app on top. The founder still builds in Lovable nine days out of ten. About 99 of every 100 commits in the app’s repository come from Lovable. Our engineers write the rest.

How Lovable and a developer share one codebase

Lovable’s GitHub sync runs in both directions. Every edit you make in Lovable becomes a commit in your GitHub repository. Every commit pushed to the branch Lovable is syncing, main by default, comes back into your Lovable editor. Lovable syncs one branch at a time. You can switch which branch it syncs, but commits on other branches stay out of the editor until they’re merged into it.

That one fact is the whole setup:

  • The founder stays on main in Lovable. Nothing changes for them. They prompt, preview and publish as before.
  • Developers work on their own branches. Lovable only shows the synced branch, so half-finished work never appears in the founder’s editor.
  • Each change arrives as a pull request. A pull request is a proposed change you can read and test before it joins main. Ours say what changed, why, how it was tested, and what has to happen after merging.
  • Merging is the handoff. Once a pull request is merged into main, Lovable syncs it and the founder’s next prompt builds on it. We check that the sync status shows the merged commit before handing back.

What merging doesn’t do

This is where most teams get caught. Lovable’s own Git sync guide is explicit: a merge doesn’t publish your app, and it doesn’t touch your backend.

Change How it goes live on Lovable Cloud
Website code Synced on merge, live only after someone clicks Publish in Lovable
Server functions (edge functions) Not deployed by a sync. Ask Lovable’s chat to deploy the named function
Database changes Not run by a sync. Run the SQL in Lovable’s SQL editor, or ask Lovable
iOS app Built separately from GitHub and released through TestFlight

Lovable Cloud also has no separate test database. Per Lovable’s database docs, drafts use the same database as your published app, and a Git branch doesn’t get its own. If a developer’s local copy keeps the production settings, its reads and writes reach the live database, so tests that change records need test accounts or a separate test backend. That’s the biggest thing a developer can’t do inside Lovable Cloud, and it shapes the rules below.

The rules that keep it safe

These are the rules we follow on this app. Each one exists because the alternative breaks something.

  1. Developers never push straight to main. Lovable treats a pushed commit exactly like one of its own edits. A direct push lands in the founder’s editor untested, and the next Publish ships it. For months, every developer change on this app has gone through a pull request.
  2. Nobody rewrites history on main. No force-pushing, rebasing or squashing commits that are already there. Lovable’s docs warn that it will replace its copy with yours. To undo something, add a revert commit.
  3. Branch protection doesn’t block Lovable. If GitHub rejects Lovable’s push to main, Lovable puts the founder’s work on a side branch called lovable-sync instead. So main stays open to Lovable, and pull requests are a team rule rather than a GitHub setting.
  4. Check that Lovable is idle and in sync before merging. Lovable’s docs recommend letting in-progress edits finish and confirming the sync status card says it’s in sync.
  5. Database changes go in first, and a person runs them. Every database change is a SQL file in the repository, even an emergency fix that had to be applied first. A person with edit access to the Lovable project runs it in Lovable’s SQL editor: read-only checks first, then the change, then queries that prove it worked. Code that depends on the change waits until it’s applied. Our engineers’ AI coding tools write migrations; they never run them against production.
  6. Server functions are deployed on purpose. After a merge we confirm Lovable has synced that commit, ask Lovable’s chat to deploy the specific function, then test the live endpoint.
  7. House rules live in the repository, where humans and AI both read them. Lovable’s agent reads a root-level AGENTS.md file on every message (Lovable’s docs), and so do many AI coding tools developers use. Ours holds rules such as keeping the visibility rules of two database functions identical, so the phone and the website show the same items. A second file covers server functions.
  8. Risky changes ship behind switches. Changes to the upload path ship behind a server-side switch that defaults to the old behavior, because an App Store build can’t be rolled back. Website changes can be switched on for the founder’s own account first.

The iOS app is a separate release

The iOS app is the web app wrapped in a native shell (Capacitor) plus custom native code. A GitHub Actions workflow builds it and uploads it to TestFlight. It runs only when someone starts it, from an admin page in the app or from GitHub, which keeps build costs down. Publishing in Lovable doesn’t update the app, so a change that touches both needs a Publish and an iOS build. More in turning a Lovable app into an iOS app.

The workflow lists every custom native file by name, and there’s no local iOS build to catch a missing entry: the iOS project is generated fresh on every run. So the workflow checks that every native file is listed and registered before it builds.

What goes wrong without these rules

  • Lovable changes code a developer wrote. Lovable doesn’t know why a line is there, and its docs say it can later modify code you wrote. They recommend recording constraints and covering behavior with tests. That’s what the AGENTS.md rules and tests are for.
  • Lovable and GitHub diverge. If each side has commits the other lacks, Lovable pushes its work to lovable-sync, and the next sync from GitHub replaces Lovable’s copy of the branch. Work stranded on lovable-sync has to be merged back by hand, which is why rule 4 says to merge only while Lovable is idle.
  • “Merged” gets mistaken for “live”. A merged fix isn’t live until someone publishes, and a server function fix isn’t live until it’s deployed.
  • A build failure that isn’t one. Lovable’s chat shows a card for each GitHub push, and that card contains a hidden “Build unsuccessful / Preview is out of date” message even when nothing is wrong. You can’t see it on screen, but an AI agent reading the page can, and will report a failure. Check the preview and the sync status instead.
  • Lockfiles drift. Lovable records new packages in package.json and its own bun.lock, but not always in package-lock.json, which the iOS build installs from. Check it whenever Lovable adds a package.

For the bugs that appear once real users arrive, see what breaks in Lovable apps.

What to ask a developer before hiring them for a Lovable app

  • Will you work through pull requests and never push to main directly?
  • How will my Lovable changes be reviewed before they reach production? Either through a review branch your developers merge, or by you publishing from main with safeguards that make that safe. Our guide to building in Lovable or Replit after you hire a developer compares the two.
  • How do server functions and database changes go live on Lovable Cloud? If the answer is “they deploy when we merge”, they haven’t done this before.
  • Who runs SQL against my live database, and what gets checked first?
  • How will you stop Lovable from undoing your work? Look for an AGENTS.md file, project knowledge and tests.
  • How will the iOS or Android app get built and released? It’s a separate pipeline from Lovable’s Publish button.
  • Do you want to move me off Lovable? Sometimes that’s right, but it should be a decision about your product, not the developer’s comfort.

If you want engineers who already work this way, our Lovable rescue can keep your project working in Lovable while we fix what’s underneath.

LET’S TALK.

Book a free 30-minute call with Virgil

Pick a time that suits you. You’ll get a straight answer on what you need, what it should cost and the fastest path to launch.

Loading available times…

Open the calendar in a new tab

Send us your project

Virgil replies personally within one business day.

Book a free strategy call