You Paid a Developer and the App Is Half Finished: What to Do Next

One line from a public founder post, printed as it was written:

I hired a developer before I was ready. $8,000 later, I had a half-finished product and a Slack channel I didn’t understand.

The last clause is the expensive part. The money has gone, and what is left behind is a set of accounts, logins and half-written things that nobody in the room can use. This page is about the next move. It does not tell you whether you were cheated, and it is not legal advice.

The first move is access. Get the code, the data and the accounts into your own name before you pay anyone to continue, then work out how much of the app actually runs, then buy the smallest next piece. Hiring first is how the same money gets spent twice.

Read on 16 August 2026, no page ranking near this question says who is allowed to move any of it. That is the part that decides whether you can act at all: on each of these platforms a specific named person is permitted to move the thing, and it is often the person who has stopped replying.

What to get back first, and who is allowed to move it

Six accounts hold a half finished app: the code, the database, the hosting, the payments, the domain and the app store listings. Each company publishes its own rule about who may move it and what the move leaves behind, and the rules do not match. Read the row before you ask.

Every row above is what the company itself publishes, read on 16 August 2026. None of it is a walkthrough of a transfer I ran, and no screens or menus are described here beyond what each company’s own page prints.

The GitHub rule is the friendliest of the six. GitHub’s repository transfer documentation states that administrator access to the repository is what the move requires, and that issues, pull requests, wiki, stars and watchers travel with it. The condition that catches people is the name: if the account receiving the repository already has one called the same thing, or a fork of it, the transfer does not happen.

The database is where the surprises live. Supabase’s project transfer guide requires you to be the owner of the organisation the project is currently in, which is precisely the role a founder who never touched the dashboard does not hold. It also lists three conditions that block the move outright, one of them an active GitHub integration connection, and warns that dropping to the Free plan “might come with a short 1-2 minute downtime”. Before any of that happens, take your own copy of the database before anything changes, because a transfer is a change and you want a copy that predates it.

Hosting has the longest leave-behind list. Vercel’s project transfer page says you must be an owner of the team you are transferring from, and that deployments, environment variables, domains, aliases, builds, the Git repository link and cron jobs all come across. What stays behind is the operational history: monitoring data, runtime and build logs, custom log drains, integrations, and Blob stores. The environment variables set inside vercel.json are also not carried. If the app has ever had an outage worth understanding, the record of it does not follow the project.

Payments are the strictest. Stripe’s user roles documentation is blunt about it: “There can only be one Owner for an account.” Both the Administrator and the Super Administrator role list changing the account owner under what they cannot do, with the parenthetical that only the owner can transfer ownership. A developer who gave you an Administrator seat gave you almost everything except the one permission that matters here.

The app stores are two different procedures with one thing in common: both leave money data behind. Apple’s app transfer overview confirms the app keeps its reviews, ratings and Bundle ID, and that the Apple Pay merchant ID does not go with it. Apple also says Xcode Cloud data must be removed before the transfer is started, and that TestFlight beta testing should be turned off for all beta versions first, by removing builds and testers and clearing the Test Information fields. Sales and payment records split at the transfer date: the sender keeps everything before it and sees nothing after. The full eligibility rules live on a separate criteria page, so nobody should treat the list here as complete. On the other side, Google Play’s app transfer help page needs the registration transaction ID for both accounts, states that “If you create a new target account, you need to pay a US$25 registration fee”, and lists payout reports, earnings reports, promotions, test groups and integrated service permissions as things that do not transfer.

A login does not make the account yours

Ownership on these platforms is a named role, and the person who left usually holds it. Stripe allows exactly one owner per account and says only that owner can hand it over. Supabase and Vercel both require you to own the organisation or team you are moving out of. Ask while they are still answering.

Being able to sign in and being able to hand the account to somebody else are two different permissions, and only one of them survives a person going quiet.

That gap is the whole reason the generic advice fails. “Secure access to your accounts” reads like a task you can complete on your own. On four of the six rows above, the platform’s own documentation says you cannot: the move needs a role you were probably never given, held by the person who has gone quiet.

So the sequence is the opposite of what it feels like. While there is still any contact, ask for the specific transfers rather than for a status update. Name them: the repository transferred to your GitHub account, the Supabase project moved to an organisation you own, the Vercel project moved to your team, ownership of the Stripe account changed to you, the domain’s authorisation code, and the app transfer started on whichever store the app is listed on. Each one is a small, defined action with a documented rule behind it, which is easier to get done than a conversation about the project.

Then there is the fork nobody enjoys. Where an account was opened in the developer’s name, with their bank details behind it, the realistic outcome is often your own new account rather than a transfer, and that is a genuine cost. A new Google Play account carries the US$25 registration fee Google publishes. A new Stripe account means the customer payment records live in an account you do not control. A new hosting project means the past logs are gone. None of that is fatal, and all of it is cheaper to discover now than after you have paid somebody to build on top of it.

How much of the app is actually built?

Three things tell you where the project stands without reading code: whether a repository you control matches what is running, whether anyone other than the person who left can start it, and whether the data inside it is real customers or filled-in examples. None of that is a judgement about quality.

Start with the repository, because it is the cheapest check. If the code you can reach and the app your customers can reach are not the same thing, everything downstream of that is guesswork. The plain version of the question, which you can ask a friend who codes in ten minutes: does the version in this repository build, and does it look like the version running at the live address?

Second, whether anybody else can start it. An app that only runs on one laptop, with settings that live in one person’s head, is worth less than the same app with a working set of instructions, and the difference is measured in the days someone spends rediscovering it. Talent has nothing to do with that gap. The question is whether the knowledge left the building with the person.

Third, whether what you are looking at is real. A screen that looks finished is not evidence that anything behind it runs. One of the 26 apps in the fixed AxonBuild audit cohort, run in June and July 2026, was a motorsport results dashboard whose Winner, Team, Laps and Time columns were fixed text written into the code, sitting in the same row as the genuine race name and date, so every race reported the same made-up result. A demo of that page would have looked complete to anyone who had not checked the numbers against a real race.

If it helps to put a frame around all three, what still has to be true before real users arrive covers the wider version of that question for an app that is closer to done than this one is.

What you are counting here is how much a stranger has to rediscover before they can safely change anything. That number is what the next quote is made of, and quality does not enter into it yet.

What it costs to finish someone else’s half built app

Three countable things move the price of finishing an app somebody else started: how many of the promised things work end to end today, whether anyone can run and deploy it without the original person, and whether real customer data is already inside it. Nobody can price it from a description.

The first is the honest measure of progress: how many complete journeys work, rather than how many screens exist. A customer signs up, pays, receives the thing, and the record of that arrives where it should. Half-built apps usually have a lot of screens and very few complete journeys, which is why the reported percentage and the remaining cost so rarely match.

The second is the part people forget to price. If nobody can deploy a change, the first paid job is getting a change to production at all, before any feature is touched, and it comes out of the same budget.

The third is the one that changes the shape of the job rather than its size. Real customer data means every change is now a change made underneath live people, with the caution and the rollback path that implies.

None of this is a happy conversation, and one corpus row records why:

I tried working with a developer. Slow, expensive…

That sentence stops mid-thought, and the distrust behind it is fair. Somebody already took money for open-ended work and delivered something unfinished. A cheaper hourly rate leaves that arrangement exactly as it was, because the rate was never the part that failed. The safer purchase is smaller and named: one working behavior, described in a sentence a non-developer can check, priced before it starts.

For the actual rates and the four routes people take, what one finished result costs across four hiring routes has the numbers, and this page does not repeat them.

One boundary worth saying out loud, since this page arrives with a price attached to it. AxonBuild’s $99 first job is available once to a new client for one agreed blocker in a working app. We complete it within three business days once access works, and you pay after seeing it work. Finishing a product that somebody else left half built is larger work and is quoted after we review the code. Anybody who quotes the whole unfinished product as one small repair is guessing.

Do this before anyone else touches the code

1. 01 Complete the transfers, and take your own copy of the data, before any new person starts. Access first, work second. Every hour of paid work done on accounts you do not control is an hour you may have to pay for twice.
2. 02 Name the behavior you want working, rather than asking somebody to finish the app. A sentence like: customers can pay and get a receipt. That is checkable by you. Finish the app is not checkable by anyone, and it is the sentence the last arrangement was built on.
3. 03 Get the price after somebody has read the code, not before. Any number quoted from a description of the app is a guess, and the person quoting it knows that, which is why open-ended arrangements exist.

There is nothing here about how to choose the person, what to ask them, or what a warning sign looks like. That is a different job, and it comes after this one.

If your app developer will not answer at all

Some of this still works without them. Any account already in your own name is yours to use today: change the password, remove their access, and stop any recurring payment you control. Where an account is not in your name, each platform publishes its own support path, and those paths are the only ones worth spending time on. What none of them do is compel a person to respond.

Two things are outside what this page can do. It cannot make somebody answer, and it cannot tell you whether you have a claim. A contract or payment dispute is a question for a lawyer where you live.

If the answer turns out to be that somebody else has to carry this from here, the search is for a developer to take over your app and keep it running, which is a different arrangement from paying for one piece of work and a different conversation from the one that just ended badly.

Common questions about paying for an app that was never finished

I paid a developer and got a half finished app. What do I do first?

Get the accounts into your own name before you spend anything else. The code, the database, the hosting, the payment account, the domain and any app store listing each have a documented transfer rule, and four of the six need a role the person who left probably holds.

Ask for those specific transfers while there is still contact, then work out how much of the app runs.

Do I own the code my app developer wrote?

What you own depends on what you agreed in writing, which is a lawyer’s question where you live rather than a web page’s. What is separate from ownership, and checkable today, is access: whether you can reach the repository, whether the accounts are in your name, and whether anyone other than the original developer can get the app running.

Those three answers decide what happens next regardless of what the contract says.

How do I get my code back from a developer who built my app?

Ask for the repository to be transferred to an account you control rather than for a copy of the files. GitHub’s documentation says the transfer needs administrator access to the repository, and that issues, pull requests, wiki, stars and watchers move with it, so you get the project’s history instead of a snapshot.

The transfer fails if your account already has a repository with the same name or a fork of it, so use a clean account name.

Can I move the app store listing to my own account?

Yes on both stores, with different requirements. Apple’s overview says the app keeps reviews, ratings and Bundle ID, while the Apple Pay merchant ID does not transfer and Xcode Cloud data must be removed first. Google Play requires the registration transaction ID for both the original and the target account, and a new target account costs a US$25 registration fee.

Neither store carries the sales history across.

What does it cost to finish an app someone else started?

It depends on three countable things: how many of the promised journeys work end to end today, whether anybody can deploy a change without the original person, and whether real customer data is already inside the app. A quote given before somebody has read the code is a guess, whoever gives it.

Count those three things yourself first, because they are the inputs any honest price is built from.

Can a new app developer work with half-finished code?

Usually yes, and it is normally cheaper than starting again. The hard part is missing access and missing knowledge rather than messy code: no repository that matches what is running, no way to deploy, and no record of why things were built the way they were.

Fix the access first and the second half of that problem shrinks to something a new person can work through in days rather than weeks.

What if there is no repository and the app only exists inside a builder account?

Then the account is the app, and the first question is whether that account can be moved to you or whether you need to start your own. Builders differ on this and their rules change, so check the specific product’s current documentation rather than trusting a general answer, and check it before you pay anyone for further work.

Until the app exists somewhere you control, every improvement is being made inside somebody else’s account.