What do I give a developer so they can take over my AI-built app?
Short answer: Give them six things: the code in a repository they can open, a list of every account the app depends on with the right access level, the settings and keys it needs (shared safely, not by email), a map of where the data lives, a list of what is broken or unfinished, and a one-page brief saying what the app is for. Lovable, Bolt and Replit are tools that write an app from a plain-English chat, and the code they produce is only half of what a developer needs. The rest is knowledge that sits in your head and in your accounts.
You built the first version with an AI tool, a developer is about to take it over, and you want to hand it over once and have it go smoothly.
I'm Ranjit, and I run Blur Studio: 15+ years building software, 120 apps taken live, and clients who have gone on to raise $10M+. I build AI systems and processes that help businesses do a lot more with a lot less time. I also work differently from most of what else is out there, more on that further down this page. Say hello.
Why a handoff pack saves you money
A developer taking over an AI-built app spends their first days answering questions you could have answered in advance. Where is the code? Which database is this? Who owns the domain? Which payment keys are live? Every day they spend finding out is a day you pay for. A good pack turns a week of detective work into an afternoon of reading. If the developer has gone, see what to do when a developer abandons your app.
The pack also protects you. Without one, access tends to end up in the wrong hands: a shared password, a developer added as the owner of your payment account, keys pasted into a chat. This guide gives you what to include, what to leave out, and a one-page brief you can copy. If your previous developer already left, read my guide on taking over software from a developer who left as well.
Step 1: get the code somewhere a developer can open it
The code should live in a repository, which is a folder of code with a full history of changes, kept on a service such as GitHub, a website where teams store and share code. Lovable's documentation says its Git sync connects a project to GitHub so the code lives in a repository you can share. It also lists limits: Git sync always creates a new repository, it cannot connect a project to a repository that already exists, and if you disconnect and reconnect, it creates another new repository. So decide once, connect once, and write down the repository's address. First confirm who owns the code you paid for.
If your builder does not sync to GitHub, my guide on how to export code from an AI app builder covers the options. Whichever route you use, make sure you own the account that holds the code, not the developer. On GitHub, you can give a person a role. GitHub's role list runs from Read to Write, Maintain and Admin, and Admin includes sensitive actions such as managing security and deleting the repository. A new developer usually needs Write. Keep Admin yourself.
Step 2: list every account the app depends on
This is the part people forget, because the AI builder set these up silently. Make a table with one row per service. Here is a starting point:
| Service type | Example | Who owns it | Access the developer needs |
|---|---|---|---|
| App builder | Lovable, Bolt, Replit | You | Editor on the project, if they will use it |
| Code repository | GitHub | You | Write |
| Database and login | Supabase, a hosted database service | You | Team member on the project |
| Hosting | The place the live site runs | You | Deploy access |
| Domain name | Your registrar | You | Usually none, ask first |
| Payments | Stripe | You | A limited team role, never your login |
| Email sending | Whatever sends your emails | You | A key for sending only |
| AI model provider | The company whose AI the app calls | You | A key with a spending limit |
For each service, invite the developer under their own email address. Do not share your login. Most services have team roles for this. A shared password means you cannot tell who did what, and you cannot remove one person without changing it for everyone.
Step 3: keys and settings, shared safely
An AI-built app runs on secrets: payment keys, database keys, email keys. A developer needs working versions to run the app, but the safest approach is to give them test versions to work with, and keep live ones in your hosting settings.
- Prefer test keys for development. Stripe, the payments company, says its test keys start with
sk_test_and live keys start withsk_live_. A developer working on test keys cannot charge real cards by mistake. - Use restricted keys where offered. Stripe's docs describe restricted keys and say to grant server-side keys only the permissions the integration needs. OWASP, a respected security nonprofit, gives the same rule for all secrets: apply least privilege, meaning each person or tool gets only the access it needs.
- Never send keys by email or chat. Use a password manager's sharing feature, or let the developer add the secrets inside the hosting dashboard themselves.
- List what the app needs, not the values. A plain list of the names (for example "Stripe secret key, Stripe webhook secret, email key") lets the developer say what is missing.
Treat any key that has ever been pasted into a chat with an AI tool, a screenshot or an email as already exposed. Plan to replace it when the handoff finishes. My AI-built app security checklist goes through the rest.
Step 4: map where the data lives
You do not need to understand the database. You need to say what is in it and who can reach it. Write down:
- What kinds of records the app stores (users, orders, bookings, files, messages).
- Which are personal or sensitive (names, emails, health or payment details).
- Where uploaded files go.
- Whether there is real customer data in the live database or only test data.
- When the last backup was taken, and where it is.
On backups, Supabase's documentation says it backs up Pro, Team and Enterprise projects daily, and recommends that free tier projects regularly export their data and keep off-site copies. Check which plan your project is on. Take a fresh backup before the developer touches anything, and keep a copy outside the platform.
Step 5: list what is broken and what is half-built
Developers can find bugs themselves, but they cannot find intent. Write down three lists:
- Broken: things that fail now, with the steps to see the failure. "Click Pay, Stripe shows paid, account stays locked" is useful. "Payments are weird" is not.
- Half-built: features that exist on screen but do nothing, or work only for you.
- Never built: things you assumed the AI had done, such as emails for failed payments or a way to delete a user's data.
Be blunt. Developers are not judging you. If you are unsure whether the AI can finish the rest or you need a person, this guide helps you decide.
What to leave out of the pack
- Your personal logins and passwords.
- Owner access on payment, hosting and domain accounts.
- Live customer data, unless the developer truly needs it. Work on a copy with fake or removed records where you can.
- Long chat histories from the AI builder. Pick out the decisions that matter and write them in two lines. Pages of prompts bury the signal.
The one-page brief to copy
Paste this into a document and fill in each line. It should fit on one page.
- What the app does: one sentence, and who uses it.
- How it makes money, or saves it: subscriptions, one-off sales, internal tool.
- Built with: the builder (for example Lovable), the database, the hosting, the payment provider.
- Where the code is: the repository address and who owns it.
- Live address: the website address and the test address, if any.
- Accounts and access: the table from step 2, with who has been invited.
- Keys the app needs: names only.
- Data: what is stored, what is sensitive, last backup date.
- Known bugs: the broken list, with steps.
- Unfinished: the half-built and never-built lists.
- Must not break: the two or three things customers rely on most.
- What I want from you: fix, finish, review, or take over completely.
- Deadline and budget: the date that matters and a number you will not go over.
- How to reach me: who answers questions, and how fast.
A worked example, with made-up details
Imagine a tutoring booking app built in Lovable by a founder named Dana (a made-up example). Her first brief says: "Parents book a slot and pay. Built with Lovable and Supabase, payments through Stripe, code on GitHub under my account. Broken: after a parent pays, the slot stays marked open. Unfinished: cancellation emails. Must not break: booking and payment. Last backup: 10 November, saved off the platform." The developer reads that in five minutes and knows to look at payment confirmation first. Dana has invited the developer with Write access to GitHub, a team seat in Supabase, and test Stripe keys. She still owns every account.
After the handoff: what you do next
- Ask the developer to confirm in writing what they can and cannot access.
- Replace any keys that were shared in an unsafe way.
- Remove the developer's access when the job ends. This is much easier when they were invited under their own email.
- Keep the brief updated. It becomes your record of how the app works.
If you are still deciding whether to build the first draft with AI and finish it with a person, my guide on prototyping with AI and finishing with a developer explains where the handoff fits. And if you do not yet know who to hire, see hiring a Lovable, Bolt, Replit or Cursor developer.
How I'd approach this
I would spend one hour on the pack before talking to any developer. Most of it is writing down things you already know. The one thing I would never skip is ownership: your name on the repository, the database, the payments account and the domain. People who skip it can end up renting their own app.
I would also be wary of any developer who wants your personal logins or owner access on day one. A good one asks only for the smallest access that lets them work. At the end, I would ask for a short written summary: what changed, what was untouched, and what to watch.
If you want someone to take a half-finished app over the line, this is the kind of work Blur Studio does. Fixes and finishes start around $1,500, agreed in writing before work starts, and you keep ownership of everything.
Questions people ask
What should I give a developer taking over my app?
The code in a repository, an invitation to each service under their own email, a list of the keys the app needs, a note on where data lives, lists of bugs and unfinished work, and a one-page brief. Keep owner access on every account yourself.
Should I give the new developer my passwords?
No. Invite them to each service with a team role under their own email. A shared password hides who did what and forces everyone to change it when the job ends. For secrets the app needs, use a password manager's sharing feature rather than email.
Can a developer take over an app built in Lovable or Bolt?
Yes, usually, if the code is in a repository they can open. Check the builder's export or Git sync options first, using my guide on exporting code from an AI app builder. Some code is easier to work with than other code, so ask the developer to look before you agree a price.
Should I rotate keys after the handoff?
Yes, for any key that has been pasted into a chat, an email or a screenshot, and for any key the developer used when the job ends. Rotating means creating a new key and switching off the old one. OWASP's guidance on secrets also recommends least privilege, so give each key only what it needs.
How do I check the quality of the code if I am not technical?
Ask a second developer for a short review before you commit to a large job, or ask the new one for a written summary of what is risky. My security checklist gives you questions you can ask without reading code.
What if the previous developer left and I have nothing?
Start by finding out which accounts you own and which are in their name. My guide on taking over software from a developer who left walks through recovering access step by step.
More in this topic: Problem solving: AI-built and no-code apps (26 guides) →
Sources
- Sync your Lovable project with GitHub (Lovable documentation)
- Repository roles for an organization (GitHub documentation)
- API keys and restricted keys (Stripe documentation)
- Secrets Management Cheat Sheet (OWASP)
- Database backups (Supabase documentation)
- Environment variables and secrets for Edge Functions (Supabase documentation)