Owning an app someone else built takes more than the code in your repository. It takes the accounts the app runs on, each with you as owner: hosting, database, domain, payments, email and the AI provider. It ends with rotating every key the previous builder held: a real secret sat permanently in git history in three apps of the 21 we reviewed from other builders.
The takeover checklist for owning an app someone else built
Owning an app someone else built comes down to ten things you can prove: the code in your repository, the hosting in your team, the domain in your registrar, every provider account in your name, the keys they held rotated, a deploy from a fresh clone, a working local setup, the documents, the developer removed, and a signed handover.
Those three apps came out of a small group: 21 third-party apps we chose to audit in June and July 2026. Because we did the choosing, three in 21 describes that group and is not a rate you can apply to AI-built apps in general. The secrets were a webhook signing secret, a live AI-provider key, and a Stripe test key with its webhook secret. The list below is the owner’s half of what a developer handoff looks like, the half you can test yourself after the builder has gone.
Two questions come before this list. Which accounts must be in your name, with a check for each that takes under a minute, is the job of the ownership checklist for your accounts. The rule each platform sets for moving an account, and why a login is not the owner role, is in the accounts step further down. Here you get the takeover in order, with a test for every row.
Technical ownership is these ten rows, done in this order and each one proven. The order matters: keys are rotated only once the accounts are yours, and the developer comes out only once the app deploys without them.
- The code sits in a repository under your own account or organization, and you can clone it. Running it on servers you rent is a later step: how to self-host an exported app.
- The hosting project is in your team, with you as its owner.
- The domain is in your own registrar account.
- Every provider account names you in the owner role, and the previous builder is removed from it. The record of that is the provider inventory a founder should hold.
- Every credential the previous builder held or could read is rotated, after the accounts have moved. The order and the rehearsal: how to rotate API keys safely.
- The app deploys from a fresh clone of your repository through your own pipeline, with no step that needs the builder tool.
- A new machine goes from clone to running by the setup guide alone. When it does not, start from why you cannot run the project locally.
- The documents exist: a README, runbooks for the jobs that recur, and an architecture diagram. What each one holds: the documentation set a maintainer needs.
- The previous developer is removed from every account and repository, on one recorded date.
- The handover document is signed, and it follows a software project handover checklist.
Each row needs a test you can run without the builder’s help and a piece of evidence you can keep. The tests and evidence in the table are what we’d ask for.
| Row | The test that proves it is yours | The evidence to keep |
|---|---|---|
| 1. Code in your repository | The repository’s settings show your account or organization as owner, and a fresh clone works | The repository address under your account, and the date it moved |
| 2. Hosting in your team | The hosting project’s members page shows you in the owner role, with billing on your card | A dated screenshot of the members page |
| 3. Domain in your registrar | You sign in to your own registrar and the domain is listed there | The registrar account name and the renewal date shown |
| 4. Provider accounts in your name | Your inventory has a line per provider: who holds the owner role, and the date the builder was removed | The inventory itself |
| 5. Keys rotated | Every key the builder held or could read has a replacement made in your account, and the old one no longer works | A dated list of replaced keys, and the first successful request on each new one |
| 6. Deploy from a fresh clone | A small visible change pushed from a fresh clone goes live through your pipeline with the builder tool closed | The deploy log with the commit |
| 7. Local setup | Someone new to the app gets it running on a clean machine from the setup guide, without asking anyone | The date, and a note of anything the guide missed |
| 8. Documents | A newcomer finds the README, the runbooks and the diagram in the repository without being told where to look | A link to each document, with the date you last read it |
| 9. Developer removed | Their name appears in no account’s members list and among no repository collaborators | The dated removal list |
| 10. Signed handover | The handover document is signed and filed with your contracts | The signed copy |
Getting the keys from an app developer is rows 4 and 5 together: the accounts come to you first, and then each key you were handed gets rotated, because the copy you received is one the developer has too. To take over an existing codebase as its owner, this list is the whole job; the engineer’s first month inside that code is a different piece of work, a legacy code takeover. An app rescue project starts from the same ten rows, since nothing gets fixed for long in an app you cannot deploy yourself.
Seen from the owner’s seat, a project takeover checklist is these ten rows. From the agency’s seat it is how to hand over an app to a client. Bringing in a new person to carry on the work has four checks of its own, set out after the verify step.
How to fill it in
Each group below has the steps, the mistake people make, and what to record. The vendor behavior in these steps comes from each vendor’s own docs, not from anything we ran.
Getting the code out of the builder
Exporting an app to git puts the code in a version control system, which tracks the history of changes to it, and GitHub is one of the services that “hosts Git repositories”. GitHub’s explanation of git covers the basics if the terms are new.
- Decide which GitHub account or organization of yours will own the code.
- Connect the builder to it, letting the builder create the repository if that is its route, or have the developer transfer their repository to you. Who is allowed to make that move is GitHub’s rule, and it takes administrator access on the repository.
- Clone it to your own machine and check that the commit history came with it.
Every builder has its own route out. For Lovable code, follow how to export Lovable code. The data in a Lovable Cloud backend is a separate job: exporting a Lovable Cloud database. A Base44 app has its own Base44 export code steps, and a Replit app has its Replit export route. To export and own the code from an AI-generated app on any other builder, start with can you export your code from an AI app builder, which says which builders export at all and what an export leaves behind.
The mistake is leaving the repository in the developer’s account with you added as a collaborator. That seat is access they gave you, so it is still theirs to take back. Record the repository address and the date it moved.
Getting the accounts
Move the accounts in this order: hosting, database, domain, payments, email, AI provider, error tracker. We put the ones that can switch the product off first.
- The person who holds the owner role on an account hands that role to your own login, by whatever route the platform sets.
- Sign in as yourself and confirm the owner role, not a member or admin seat.
- Write down the date the role moved and who holds it now, as a line in your provider inventory.
The steps to transfer accounts to the founder differ on every platform, and each vendor publishes who may make the move and what stays behind.
| Account | Who can move it | What stays behind |
|---|---|---|
| Code on GitHub | Someone with administrator access to the repository; moving it into an organization also needs owner permissions there or admin on the repository | Nothing moves if your account already has a repository of the same name or a fork in the same network; a GitHub Pages site is not redirected |
| Database on Supabase | The owner of the organization the project sits in, who must also be at least a member of yours | An active GitHub integration, project-scoped roles or log drains block the move; leaving a paid plan for Free can bring a short 1-2 minute downtime; the region does not change |
| Hosting on Vercel | An owner of the team the project leaves, who is also a member of yours | Integrations, monitoring data, runtime and build logs, custom log drains, and environment variables set in vercel.json; Vercel Blob has its own transfer route |
| Payments on Stripe | Only the account owner: “There can only be one Owner for an account” | Nothing relocates; what changes is whose name the account is in |
| Domain | Whoever controls the registrar account the name sits in | Each registrar sets its own transfer rules and locks; ask for the transfer authorization code and leave the DNS records as they are until the move is done |
| App on Apple’s App Store | The developer account that holds the app sends it to yours | Reviews, ratings and the Bundle ID stay with the app; the Apple Pay merchant ID does not move, and Xcode Cloud data has to be removed first |
| App on Google Play | You need the registration transaction ID of both accounts | Payout and earnings reports, promotions, test groups and permissions for linked services stay behind; a new target account costs a US$25 registration fee |
A login is not the owner role. Stripe lists “Change the account owner (only the owner can transfer ownership)” among what both its Administrator and Super Administrator roles cannot do , and Supabase and Vercel each need an owner of the organization or team the project leaves. A developer who gave you an admin seat gave you almost everything except the one permission that moves the account, so ask for each transfer by name while they still answer. A contractor who will not hand anything over has given you an ownership problem before any code problem; where an account was opened in their name, with their card behind it, a new account of your own is often the realistic route, and it starts without the old one’s history. The mistake is stopping at a login.
Rotating the keys the builder held
- Wait until rows 2 to 4 are done and the accounts are yours.
- List every key the previous builder created, saw or could read.
- Replace each key that was created under the developer’s own provider account with a new one created in yours.
- Rotate the keys in accounts you keep, and expire each old key once the app runs on its replacement and nothing uses the old one any more.
Rotating before the accounts move leaves the new keys where the builder can still see them, which is why step 1 waits. The list in step 2 follows one rule: rotate a credential that was exposed, may have been exposed, or was available to someone whose access you can no longer trust, and leave alone a key that person never had, because a staffing change on its own is no reason to rotate. If the builder set the app up, that rule covers the keys it runs on, because they could read them.
As far as we know, a key in an account you keep does not stop working because the person who created it left. On Stripe, for example, “Code that uses the expired key can no longer make API calls”, and “When you rotate a key in the Dashboard, both the old and new keys work for up to 7 days.” Until the old key expires, the builder’s copy works as well. Stripe’s advice is to check the old key’s request logs and “expire it only after its request volume has been at zero for a few hours or days.” In a takeover we’d keep that window as short as the logs allow. The Expiration dropdown you see when you rotate sets it, and “If you choose Now, the old key is deleted.” Stripe’s guide to API keys has the click path.
The three apps in the opening line are the reason to look past today’s files and into the history. Finding what the builder left there is secret scanning; the rotation order and the rehearsal are row 5’s job. The mistake is rotating on day one while the builder still holds an owner seat. Record each key, where it lives, the date it was replaced, and the first successful request on its replacement.
Running it from your own clone
- Clone your repository onto a clean machine.
- Copy the environment example into place and fill it with your own values.
- Run the one setup command the guide names, and open the app.
- Push a small change and let your own pipeline deploy it.
Take a founder who has the repository and the provider accounts in their own name and runs the first deploy from a fresh clone. The deploy stops at a step that still depended on the builder tool the app was generated in. Until a fresh clone deploys with no step that needs the builder tool, part of the app still belongs to the tool, and an app that only exists inside the builder tool cannot be reviewed, rolled back, or handed to another engineer.
The mistake is a deploy step that still calls the builder tool or the developer’s machine, or runs on a token in the developer’s own name; expect it to stop working the day row 9 removes them. Record the date, the commit, and a note of anything the guide missed.
Offboarding the developer
Onboarding gives a person the access their work needs, and offboarding takes every piece of it back. In the onboarding and offboarding process for one app, the offboarding half happens on a single day:
- Remove the developer from every account and every repository on the same day, and record the date.
- Delete the deploy keys and API tokens they created in your accounts. Removing their seat does not, as a rule, delete what they created, and a token that lives in their own account is not yours to revoke; you can only remove the access it had.
- On Stripe, check the sandboxes as well as the live account. Stripe says “You can assign a different role in a sandbox than the one the user holds in other sandboxes or in your live account or organization”, and a member is removed in “the live account, live organization, sandbox, or organization sandbox where that user has a role assignment”.
- Put any open questions to the developer in writing, with the date you asked.
For the next developer the same list runs in reverse: each seat is named when it is given, so each one can be taken back on one day. For a single app, an IT discovery checklist is the provider inventory from row 4.
A filled example
Assume one app. A contractor built it on Lovable, with a Supabase backend, Stripe for payments and an AI provider key, and the code sits in the contractor’s GitHub account. This is an illustration with stated assumptions, not a client’s story; how each account moves is in the Lovable export article and the accounts table above.
| Row | What it means for this app | The evidence to keep |
|---|---|---|
| 1 | The repository moves from the contractor’s GitHub account to yours | The repository address under your account |
| 2 and 4 | The Lovable project, the Supabase project and the Stripe account each show you in the owner role | The owner role shown in each dashboard |
| 3 | The domain sits in your own registrar account | The registrar listing |
| 5 | The AI provider key and the Supabase service key are replaced with keys made in your accounts, and the Stripe keys are rotated | The dated list of replaced keys |
| 6 and 7 | A fresh clone deploys through your pipeline, and a clean machine runs the app from the environment example | The deploy log |
| 8 | The README, runbooks and diagram live in your repository | A link to each |
| 9 | The contractor is removed from GitHub, Lovable, Supabase and Stripe on one recorded date | The dated removal list |
| 10 | The handover document carries both signatures | The signed copy |
How to verify the result
Ownership has one combined test: remove the previous builder from every account and repository, then deploy a visible change from a fresh clone, take a test payment, and read a new log line. If any of the four fails, one of the ten rows is not done yet.
Keep the proof of each: the removal list that shows the builder gone, and the deploy log naming the commit that went out. For payments, a production app on live keys takes no test-mode payment, so take the test payment in the provider’s test mode on the staging deploy, and then find the live key’s first successful request after rotation in the provider’s request logs, which Stripe opens from each key’s menu. The new log line carries its own timestamp. Write down all four with the date.
When we run the Production Hardening Sprint, rows 4 to 7 each have a written verify step of their own. Deliverable 2.8 is verified this way: “Produce an inventory listing each provider, the owning account, the owner role holder, and the date the previous builder’s access was removed.” For 2.6: “Rehearse rotation with a test credential and record the affected services and checks.” For 7.11: “Deploy a fresh clone to staging through the pipeline with no step that depends on the generating tool.” For 10.10: “Go from clone to running application on a new machine by following the guide alone.”
Checking what the builder handed over
Checking an AI-built app someone else delivered starts with eight requests to the person who built it, sent in one message before the final payment goes out. Each asks to be shown something that opens on screen, so you can grade the reply without reading code: a straight answer names a specific thing you can open, and a stalling answer names a category.
| Ask to be shown | A straight answer | A stalling answer |
|---|---|---|
| 1. The thing you paid for, done on an ordinary paid account while you watch | They sign in as a normal customer, do it end to end in the live app, reload, and the result is still there | They open the code, play an earlier recording, or say the demo account is broken |
| 2. Where the last error a customer hit was recorded | They open the place errors collect and read out the latest one, with its time and page; “nothing records them” is also a straight answer | ”Errors are logged” or “the host handles it”, with no place named or opened |
| 3. What runs between a change and customers seeing it | They name the check, say what happens when it fails, and point to a time it stopped a release | ”We test before release” with nothing named, or “the platform deploys automatically” |
| 4. What a stranger can do without signing in | They list the public pages and actions and what each one can reach | ”Nothing important”, while sign-up and password reset are plainly public |
| 5. A second customer account, made in front of you, that cannot see the first one’s data | They create it, sign in, open the place the first account’s data would show, and it is empty | ”The database is secure”, a security product’s name, or an offer to check later |
| 6. Which accounts and cards are in your name and which are in theirs | They go down the list out loud: hosting, repository, database, domain, AI provider, payments, email sender | ”Everything transfers at the end” or “it is all under our agency account for now” |
| 7. What a new person would need to make a change next month | Where the code lives, how someone else runs it on their own machine, and which keys a newcomer needs on day one | ”Any developer can pick it up”, with no starting point named |
| 8. What was left unfinished, and what they would fix first with a week | Two or three named things, and one of them picked | ”It is all done”, or a list of new work to buy |
Some honest answers are a plain no. Of the 21 apps built by other people that we audited in June and July 2026, 17 recorded customer errors nowhere and at least 17 had no deploy gate , so “we have nothing for that” on requests 2 and 3 is a common gap with a known fix, not a confession. We picked those apps for the audit rather than drawing them from every AI-built app, so the counts show what is common, not what your app holds. Vagueness is the tell: a builder who cannot say what runs knows less about the running app than one who says nothing does.
Ask while money is still owed. Every request costs the builder almost nothing while the job is open, and the same eight read very differently three weeks after the last invoice is paid. Word them as the last step of the job: “Before I pay the final invoice, can you walk me through these eight things?”
Three of the requests, and several gaps no answer reaches, need someone to read the code. In the same audits, by how often each turned up:
- No working test anywhere: at least 18 of the 21 apps.
- A stranger or a free account could run up the AI bill: 12 of the 14 apps with an AI feature.
- No rate limit on the most expensive endpoint: 13 of the 21 apps.
- The server accepted what the browser asserted, such as a price or a role: 10 of the 21 apps.
- A framework version with a publicly known, reachable hole: 9 of 26, a count that includes five apps of our own.
- A signed-in customer could reach another customer’s data: 7 of 21 confirmed.
- A real secret shipped: 6 of the 21 apps.
A builder who answers honestly about those is telling you what they believe; being shown takes a reading of the code.
When someone new takes over the running of it
A takeover of the day-to-day work is finished when the new person can run the app without you, ship a change through something that checks it first, undo that change, and see it when it fails, all through accounts your business owns. Accepting an invitation to your repository is none of the four.
| What has to work | What it looks like when it is true | What to ask before you pay |
|---|---|---|
| They can run it | The app starts on their machine from the repository and the list of settings, without you on a call | ”Can you get it running in a limited test environment, without production secrets or customer data? If not, what stopped you?” |
| They can ship a change | A change goes out through a path that runs the tests and blocks the release when they fail | ”When you push a change, what has to pass before customers see it?” |
| They can undo it | A bad release goes back to the previous version, and there is somewhere other than production to try things | ”If a change goes wrong on a Friday, what exact sequence puts it back?” |
| They can see it fail | A customer’s error is recorded where a person looks, and someone is told when the app stops answering | ”How will you find out something broke, and how will I?” |
Before a candidate sees private code, put confidentiality terms in writing, give the least access the test needs, and use a test environment with sample data rather than production secrets. Their access stays named and removable, and the accounts stay in the business’s name, as rows 1 to 4 set up.
Buy the first job small. Pick one thing that is broken, risky or unfinished, that you can describe without a technical word and can tell is done: the sign-up emails land in spam, or the report page times out. Agree in one plain sentence what working means, such as “a new customer signs up and the confirmation email reaches a Gmail and an Outlook inbox within a minute”. When it is delivered, run the four checks above. A fix that went out through a check, can be put back and would be noticed if it broke is worth more than a faster fix made straight on production. Any ongoing arrangement is a second decision, made after the first job lands.
What never moves to the person you pay
For a non-technical founder, five standing jobs stay yours whoever you hire, and a sixth, reading the code, is the one you buy as a job with an end.
| The job | Why it stays with you |
|---|---|
| Deciding what right looks like | Nobody reading the code can tell a rule is wrong if it was never written down, such as a 14-day refund window the app gives as 30 days |
| Keeping the accounts in the business’s name | Someone can set an account up for you, but only you can be the name on it |
| Hearing that it broke before a customer says so | The person who built it has moved on, and the inbox the complaints reach is yours |
| Owning what it earns and costs | The cards are yours, so rising usage, an ended free tier or a price change reaches nobody else |
| Being able to hand the whole app on | Only the holder can give it, and it mostly follows once the other four are done |
Reading the code is the sixth job and the only one that leaves you. It leaves once, as work with an end, and judging whether the reader really looked stays with you: a real reading names the file or route, shows the behavior in the running app, and says what it did not cover.
Where the sprint does this
The verify steps above check the work; deliverable 2.8 is the work itself, and in it we “Move every service the product depends on (database, hosting, payments, email, AI, domain) into an account the founder owns, with the founder as the owner role, billing in the founder’s name, and any previous builder removed.” At handover you receive a readiness report and technical due diligence pack, with the architecture diagram and data model in it, and instructions for releases, backups, recovery, and incident response. Every item is recorded in the production readiness report, which has to “Account for all 123 IDs; keep failures visible until resolved and explain genuine non-applicable items.” Hosting, paid tools, and API usage remain in your accounts. If you would rather have the takeover done and proven than run it yourself, talk it through first in a free audit: a video call where we go over the takeover with you and agree which step carries the most risk. In the sprint, the account moves, key rotation and fresh-clone deploy above are deliverables, and the published scope lists each one.
Common questions about taking over an app
How do I transfer an account to another?
The person who holds the owner role on the account hands that role to your account and is then removed from it, and you record the date as a line in your provider inventory. On most platforms only that owner role can make the move: Stripe allows one owner per account, and Supabase and Vercel each need an owner of the organization or team the project leaves.
How to get the code from an app?
Ask the developer to transfer the repository to an account you control rather than send you a copy of the files. On GitHub the person moving it needs administrator access to the repository, and issues, pull requests, wiki, stars and watchers move with it, so you get the history and not a snapshot. The transfer fails if your account already has a repository of the same name or a fork in the same network, so check that before you ask.
Is it safe to give your API key?
It is safer not to: give a developer their own seat in the account and let them create their own keys, rather than handing over yours. A key you did share is one they could read, so rotate it when their access ends. Stripe’s docs also say “Don’t share keys over email, chat, or other unencrypted channels.”
Will an API key expire?
Generally no, not just because the person who created it left, if the key lives in an account you keep. On Stripe, a key stops making API calls once it is expired, and a rotated key lasts until the expiration you pick at rotation. Other providers set their own rules, so read each provider’s docs before assuming a key has lapsed.
What’s the difference between git and GitHub?
Git records the history of your code inside the repository, and GitHub is a service that stores repositories online and adds tools such as pull requests and code review. The Pro Git book says Git “thinks about its data more like a stream of snapshots”: at each commit, it takes a picture of what all your files look like. For a takeover, the difference matters in one place: the repository on GitHub has to sit under your account, not the developer’s.
Did someone else build the app you now own?
If the builder still holds the accounts or keys, you can be locked out of your own product, or exposed after they leave. Bring it to an audit: we go over with you who controls the hosting, domain, payments and keys today. You get a clear view of which handovers to finish first.
Book a free audit →
Free · 30 minutes · No code access needed