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
mainin 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.
- 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. - 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. - Branch protection doesn’t block Lovable. If GitHub rejects Lovable’s push to
main, Lovable puts the founder’s work on a side branch calledlovable-syncinstead. Somainstays open to Lovable, and pull requests are a team rule rather than a GitHub setting. - 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.
- 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.
- 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.
- House rules live in the repository, where humans and AI both read them. Lovable’s agent reads a root-level
AGENTS.mdfile 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. - 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.mdrules 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 onlovable-synchas 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.jsonand its ownbun.lock, but not always inpackage-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
maindirectly? - How will my Lovable changes be reviewed before they reach production? Either through a review branch your developers merge, or by you publishing from
mainwith 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.mdfile, 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.
