How to hire someone to fix your AI-built app without losing control of it

In short: before anyone touches your app, make sure the code, database, domain and payment accounts are in your name. Give each person the narrowest role that lets them work, never your own passwords. Start with a fixed-price diagnosis that delivers a written, ranked list of problems and a plan with prices. Be wary of proposals that promise a rewrite or a timeline before anyone has looked at the code.

11 min read

In short

  • Ownership first: repository, Supabase organization, domain, hosting, payments and app stores in your company’s name.
  • Invite people into your accounts with limited roles; do not share owner logins or send secret keys over chat.
  • A good diagnosis has a fixed price and a fixed duration, and ends with a ranked list of findings, a plan, prices and a rescue-or-rewrite recommendation.
  • Red flags are practices, not people: a quote without seeing the code, hosting in the contractor’s name, no written scope, promises of total security.
  • When the work ends, remove access and rotate the keys.

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.

Should be in your company’s name
  • 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
How to hand it over
GitHub
In a GitHub organization, give the person the Write role on the repository. It lets them push code but not delete or transfer the repository or change its settings — those need Admin, which stays with you.
Supabase
Invite them to your organization. The Developer role gives full access to project content but cannot change project settings; Owner and Administrator can do much more. On Team and Enterprise plans you can also limit a member to specific projects.
Secret keys
Do not paste them into chat, email or SMS. Supabase recommends having the other person read the key from Settings → API Keys themselves, or using the encrypted sharing in a password manager.
Hosting, payments, app stores
Use each platform’s team invitations with a limited role, not your owner account. Two-factor authentication stays on your side.
Production data
For a diagnosis, read access is often enough. Discuss in advance whether the person needs to see real customer data at all, and how it is handled.

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.

A diagnosis report should include
  • 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.

Option
What to weigh
Independent developer
Often lower cost and direct contact with the person writing the code. The risk is concentration: illness, a new job or a full calendar stops the work. Ask who covers for them and how knowledge is written down.
Agency or studio
Usually higher cost, with a team that can cover security, backend and mobile and continue if someone leaves. The risk is distance: make sure you know exactly who works on your app and that you talk to them, not only to a manager.

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

Terms worth having in writing
  • 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

Offboarding in five steps
  1. 01

    Collect the handover

    Documentation, the list of services and their costs, and instructions for deploying and restoring.

  2. 02

    Check that everything is in your repository

    Including configuration and database migrations, not only application code.

  3. 03

    Remove access

    Go through your access log: GitHub, Supabase, hosting, payments, app stores, builder accounts.

  4. 04

    Rotate keys

    Create new secret keys for anything the person could see, switch your app to them, then retire the old ones.

  5. 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.

  1. 01GitHub docs: Repository roles for an organization — Write cannot delete or transfer a repository or change its settings; Admin can
  2. 02GitHub docs: Transferring a repository — Admin access required; issues, pull requests and wiki move; redirects; one day to accept
  3. 03Supabase docs: Access control — Owner, Administrator and Developer roles; project-scoped roles on Team and Enterprise plans
  4. 04Supabase docs: Understanding API keys — Never share secret keys over chat, email or SMS; let the other person read them from the dashboard
  5. 05Supabase docs: Database backups — Deleting a project permanently removes its data, including backups
dbit.one engineering desk
The engineers who build these systems

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

Related services

Read next

Questions about your project?

Describe your task — within 24 hours we’ll come back with an estimate, timeline and plan.

hello@dbit.one