Start with ownership, not with a contractor
Founders who built an app with Lovable, Bolt, Replit, Cursor or v0 often discover, when something breaks, that pieces of it are registered to whoever helped along the way: a friend’s GitHub, a freelancer’s Supabase account, a domain bought on a personal card. Before you hire anyone, bring every piece under your company. It protects you from the worst case with any contractor, including a good one who simply moves on.
- The code repository — ideally a GitHub organization you own, not a personal account.
- The Supabase or Firebase organization, with you as owner.
- The AI builder account where the project lives.
- The domain registrar and DNS.
- Hosting (Vercel, Netlify or similar) and any cloud accounts.
- The payment provider account.
- App Store and Google Play developer accounts.
- API accounts for paid services — AI, email, SMS — with billing on your card.
This is not about distrust. On Supabase, for example, deleting a project permanently removes all its data, including backups. Whoever owns the account owns that button.
If code currently sits in someone else’s GitHub, they can transfer the repository to you: they need admin access to the repository. A transfer to a personal account is accepted by email within one day, before the invitation expires; a transfer into your organization needs them to have permission to create repositories there. Issues and history move with it, and old links redirect.
How to give access safely
The rule is simple: invite people into your accounts with the narrowest role that lets them do the job. Never hand over your own login, and never send secret keys in a chat or email.
What a diagnosis should deliver
The first paid step should be a diagnosis, not a fix. It has a fixed price and a fixed duration, and it ends with documents you keep regardless of whom you hire next. Here is what a useful one contains.
- An inventory of accounts and who owns each, with what still needs to be transferred.
- Security findings ranked by risk — exposed tables, missing or wrong RLS policies, keys in the browser or repository — each with evidence reproduced on your own test accounts.
- The state of payments: how orders become paid, whether duplicates are possible, a reconciliation against the provider’s records.
- Backups: whether they exist, where, how old, and whether a restore has been tested.
- Monitoring: what is watched today and what is not.
- Code health in plain language: tests, outdated libraries, the parts that break most often.
- A recommendation — rescue, rescue in parts or rewrite the core — with the reasoning.
- A plan in phases, each with a price and a timeline, plus what can safely be left alone.
Ask before you pay what the report will contain and in what form. A team that cannot describe what you will receive is asking you to buy a surprise.
Red flags in proposals
Good freelancers and good agencies avoid the same mistakes, and less experienced ones of both kinds make them. Judge the practice, not the label.
- A firm quote or “rewrite everything” before anyone has seen the code. Neither is possible to know without a look inside.
- Hosting, repository or database set up in the contractor’s name “for convenience”. Convenient until the relationship ends.
- A request for your owner password instead of an invitation with a limited role.
- Open-ended hourly work with no written scope, no milestones and no definition of done.
- No mention of access rules, payments or backups in a proposal to fix an AI-built app. Those are where these apps usually fail.
- Absolute promises: “100% secure”, “guaranteed App Store approval”, “we will fix it in a weekend”. Nobody can promise outcomes that depend on third parties or on code they have not read.
- No way to verify the work: no access for your own engineer, no demos, no tests you can run.
Freelancer or agency
Both can do this well. The difference is in how risk is spread, not in skill.
Either way, the same safeguards apply: your accounts, a written scope, a fixed-price diagnosis first, regular demos and the right to have someone else review the code.
What to put in the contract
- The contract says when the code and the rights to it pass to you, for example after each paid milestone, and what is handed over with it.
- The domain and service accounts are in your name.
- Scope, price and deadline are fixed after the diagnosis, phase by phase.
- A working version shown at a regular interval, not only at the end.
- Consequences for missed deadlines.
- Who fixes bugs in the delivered work, for how long, and at whose cost.
- Documentation and a handover at the end: where things live, how to deploy, how to restore.
- Confidentiality for your data and your customers’ data.
For reference, here is how we write ours. Price and deadline are fixed; for each day of delay the invoice drops by 2%, capped at 10%. You see a working version every two weeks. Your own engineer may review the code, and if they find a contract item we did not deliver, we refund 10%. The rights to the source code and data pass to you once it is paid for, and the domain and service accounts are in your name. Bugs in our work are fixed free of charge for the lifetime of the product.
When the work ends
- 01
Collect the handover
Documentation, the list of services and their costs, and instructions for deploying and restoring.
- 02
Check that everything is in your repository
Including configuration and database migrations, not only application code.
- 03
Remove access
Go through your access log: GitHub, Supabase, hosting, payments, app stores, builder accounts.
- 04
Rotate keys
Create new secret keys for anything the person could see, switch your app to them, then retire the old ones.
- 05
Do a test restore
Restore the latest backup somewhere safe to confirm you can recover without help.
How we approach it
Our project rescue begins with exactly this kind of diagnosis: five working days, a written report and a plan with prices. In 2026 it costs $1,500–3,500; stabilization and relaunch ranges are on the pricing page. We work from Tashkent, inside your accounts, with roles you grant and can revoke. The report is yours whether or not you continue with us. Before the call, it helps to run the self-check in what to check first in a vibe-coded app and the Supabase RLS checklist; for the decision that follows, see rescue or rewrite.
Frequently asked questions
Should I give a developer my Supabase password?
No. Invite them to your Supabase organization with a role such as Developer, which gives access to project content but not to project settings. Keep the owner role and two-factor authentication to yourself.
How much does it cost to fix an AI-built app?
It depends on what the diagnosis finds. With us, the diagnosis costs $1,500–3,500 in 2026, stabilization $6,000–15,000 and a full relaunch $15,000–50,000. Be cautious of any firm price given before someone has looked at the code.
Is a freelancer or an agency better for fixing a vibe-coded app?
Either can be. A freelancer is often cheaper and more direct; an agency spreads the work across a team. What matters more is the practice: your accounts, a written scope, a diagnosis first and the right to have the work reviewed.
Our code is in the previous developer’s GitHub. How do we get it?
Ask them to transfer the repository to your account or organization. They need admin access to the repository. A transfer to a personal account is confirmed by email within one day; for a transfer into your organization, give them permission to create repositories there. Issues and history move with it, and old links redirect.
What should we do when the developer’s work is finished?
Collect the documentation, confirm everything is in your repository, remove their access everywhere, rotate any secret keys they could see and test that you can restore a backup on your own.
Sources
Every claim here can be checked: below are the primary sources, not a retelling.
- 01GitHub docs: Repository roles for an organization — Write cannot delete or transfer a repository or change its settings; Admin can
- 02GitHub docs: Transferring a repository — Admin access required; issues, pull requests and wiki move; redirects; one day to accept
- 03Supabase docs: Access control — Owner, Administrator and Developer roles; project-scoped roles on Team and Enterprise plans
- 04Supabase docs: Understanding API keys — Never share secret keys over chat, email or SMS; let the other person read them from the dashboard
- 05Supabase docs: Database backups — Deleting a project permanently removes its data, including backups
These articles are written by engineers working on the projects and published under the desk’s name. The studio and the desk’s published rules stand behind every text, not a single author; articles about our own open-source code carry the author’s name.
How we write and what we verify