Late, buggy or abandoned by its developer, an unfinished product forces an expensive choice. These ten checks help founders judge ownership, code, data and scope, then pick the safest route to a usable release.
The last commit message in the repository reads "fixes". It was saved on a Friday, five months ago, by the freelancer who built version one of your product and stopped answering email soon after. You now hold a half-built MVP that mostly works, sometimes crashes and cannot be explained by anyone on your team.
Two instincts compete at this point. One says keep patching, because a rewrite feels like paying twice. The other says burn it down, because anything left by a departed developer feels contaminated. Either can be right, and either can swallow the rest of your runway.
Money already spent is the least useful number on the table. What counts is the cost, time and risk of reaching a product customers can actually use, and which path is least likely to leave you stuck again. That depends on facts about ownership, structure, data and scope, most of which can be checked in days.
The ten questions below run in the order that tends to expose the deciding facts first. Some need a developer's eyes and many need only a careful afternoon. Before the first one, it helps to be exact about what the three options mean.
What counts as a half-built MVP, and what are the three ways forward?
A half-built MVP is a minimum viable product whose build has stalled, drifted or lost its developer before real customers can use it. Founders then have three paths: repair the existing code, rebuild only its weakest parts, or rewrite the product from scratch while keeping what they have learned about users, data and design.
The paths differ in how much existing work survives, and each has a typical way of going wrong.
| Path | What it means | Best when | Watch out for |
|---|---|---|---|
| Repair | Keep the code, fix the bugs, finish the features | Structure and data are sound and bugs are scattered | Patching weak foundations while costs drift upward |
| Partial rebuild | Replace the weakest modules and keep the rest | Trouble clusters in one or two areas | New and old code that never quite fit together |
| Rewrite | Build a new codebase, keeping designs, learning and data | Structure, data model and stack all work against you | Rebuilding the same drifting scope and losing hidden knowledge |
An illustrative founder
Picture a composite founder, invented for this article, who runs a booking tool for independent dog groomers. A freelancer built the first version and left. The app takes bookings, but it double-books on busy weekends, sends some reminders twice and has never been released through the app stores.
The founder's first reaction is to ask for a full rewrite. The questions below show why that reaction deserves a test first, and the example returns at a few points to show what an answer can look like.
1. Does the core user flow work from start to finish?
A half-built MVP passes this test when a new user can finish the one job the product exists for, such as signing up, booking and paying, without a developer stepping in. If that path breaks, nothing else matters yet. If it works but looks rough or runs slowly, you are probably looking at repair, not rewrite.
How to check it
Test it the way a stranger would:
- Write the product's one job in a single sentence.
- Create a brand-new account instead of using your admin login.
- Complete the job on a laptop and on a phone.
- Note every error, dead end and step that needs someone to edit the database behind the scenes.
What the answer tells you
A flow that works only because a developer fixes data by hand does not work. One broken step with a clear cause suggests repair. Breaks in several unrelated places suggest weak structure, which Question 4 tests directly.
Stuck with code you did not write?
If the first answers leave you unsure, a short outside review of what you hold is the sensible next move.
Review what you have2. Can anyone build and run the code today?
A repository is an asset only if someone can build, run and deploy the product from the files you hold. Many abandoned MVPs run solely on the former developer's laptop, using settings and secret keys stored nowhere else. If a fresh developer cannot start the app within a day or two, every estimate is a guess.
How to check it
Ask a developer with no stake in the outcome to try the following on a clean machine, with a time limit:
- Download the code and follow the readme, if there is one.
- Start the app locally and note each missing setting, package or secret key.
- Load the database and run the automated tests, if any exist.
- Deploy to a test server, never the live one.
What the answer tells you
Failures here are usually fixable and rarely justify a rewrite. They do mean that every price you are quoted stays provisional until the app runs. A short, paid investigation to get it running is a smaller commitment than a rewrite chosen out of frustration.
3. Do you own everything the product runs on?
Ownership of an MVP covers more than the code. It includes the repository, the domain, hosting and database accounts, app store listings, payment and email providers, and licences. If any of them sit under a former developer's personal login, you hold an unfinished product with a hidden dependency that no rewrite will remove.
How to check it
Make a list and tick each item only when you can log in yourself:
- The code repository, including its full history
- The domain name and its DNS settings
- Hosting, database and backup accounts
- App store developer accounts
- Payment, email, SMS and analytics providers
- Design files and third-party licences
- A written agreement that assigns the code to your company
In the illustrative example, the hosting account and the app store listing might both sit under the freelancer's personal email, which is common in one-person builds.
What the answer tells you
Treat ownership as a gate, not a detail. Move accounts into your company's name, change every password and key after the handover, and get each transfer confirmed in writing. If the former developer cannot be reached, a lawyer rather than an engineer should advise on rights to the code. This article is not legal advice.
4. Could a new developer understand the code within a week?
Readable code has a clear structure, sensible names, a short readme and consistent patterns, so a competent newcomer can find where a feature lives and change it safely. When logic is copied across files and nothing explains why, each change takes longer and breaks something else. That is the strongest signal for rebuilding.
How to check it
Ask a reviewing developer to make one small, real change, such as adding a field to a form, and to report the time taken and the surprises met. Then have them look for these warning signs:
- Little or no automated testing
- The same logic copied into several files
- Single files running to thousands of lines
- Large blocks of commented-out code
- Packages several major versions out of date
What the answer tells you
A newcomer who finds their way within days points toward repair. A newcomer who needs a guide to every folder points toward rebuilding the tangled modules. A mess in one module is not proof of a mess everywhere, so ask where the damage sits before deciding how far to go.
5. Are the bugs scattered or clustered?
Bugs are scattered when they appear in unrelated features with unrelated causes, which suggests ordinary unfinished work that repair can clear. They are clustered when most come from one area, such as payments, permissions or syncing. Clustering points to one weak module that deserves a targeted rebuild, not a rewrite of everything.
How to check it
Export the bug list or the support messages, then label each by feature area and likely cause. If no list exists, start a spreadsheet and keep it for one week of real use. Add two more columns: severity, and whether a past fix of the same bug has ever failed or reappeared.
What the answer tells you
Scattered bugs that stay fixed support repair. A cluster supports a partial rebuild of that area. If fixing one bug regularly creates another elsewhere, the cause is probably structure or the data model, so weigh Questions 4 and 6 more heavily.
6. Is the database designed for the product you now know you need?
The data model is the set of tables and relationships that store your information, and it is the hardest part of an MVP to change later. If it reflects how the business really works, much of the code above it can be repaired. If it fights the business, a rewrite of the layers above it inherits the same problem.
How to check it
Ask a developer to draw the database layout, then walk through five real situations to see whether it copes:
- A refund on a partly used order
- A booking that is cancelled and rebooked
- One person holding two roles, such as customer and staff member
- A customer who changes plan midway through a billing period
- A request to delete one person's data
Also check that all of it can be exported cleanly. Duplicate records, missing relationships and dates stored as plain text are common faults.
What the answer tells you
A sound data model keeps repair and partial rebuild on the table. A flawed one means the foundation needs rework and a careful migration plan. In almost every rewrite, the exported data and its mapping are the most valuable thing to carry across, so protect them whichever path you pick.
7. Is the problem the code or the plan?
Many MVPs stall because the requirements kept changing, not because the code is poor. When features were added without a priority list, the developer was guessing and the product drifted. Rewriting in that situation repeats the drift in a new codebase, so the scope decision must come before the repair-or-rewrite decision.
How to check it
Write one page: who the user is, the one job the product does, the five features the first release needs, and what is deliberately left out. Compare it with what has been built, then ask three things:
- How many built screens did customers actually ask for?
- How often did the requirements change in the last six months?
- Did the developer work from written specs, designs or acceptance criteria?
What the answer tells you
If you cannot write the page, pause spending until you can. In the illustrative example, the founder might find several screens that no customer interview ever asked for. Cutting scope lowers the price of every path, which makes this one of the cheapest and most valuable questions to answer.
8. Is the technology stack still a sensible choice?
A technology stack is the combination of languages, frameworks, database and hosting that the product is built on. It is a sensible choice if it is current, well supported and easy to hire for. An obscure framework, an end-of-life version or a stack chosen for the developer's personal taste can justify rebuilding even when the code works.
How to check it
List each part of the stack with its version, then ask:
- Is every part still maintained and receiving security fixes?
- Could you hire two developers who know it within a reasonable time?
- Did the original developer write a custom framework where a standard one exists?
- Will it support the mobile or integration needs of the next year?
What the answer tells you
Old versions on a mainstream stack are upgrade work, which is repair-sized. A niche or abandoned stack raises the case for rebuilding the affected parts. Plain, common technology usually serves an MVP better than a fashionable choice, so judge it by hiring and support, not by novelty.
9. Are security, payments and backups in place?
Security basics for an MVP mean hashed passwords, sensible access rules, secret keys kept out of the code, tested backups and a payment flow that never stores card details itself. A product handling real customer data without these is a liability whatever its feature list, and fixing them comes before launch or further feature work.
How to check it
Put these questions to the reviewing developer:
- Are passwords and secret keys stored safely, away from the repository?
- Can one user see another user's data by changing a number in the web address?
- Do backups run automatically, and has a restore ever been tested?
- Does a recognised payment provider handle card details?
- Are admin accounts protected with a second verification step?
What the answer tells you
Most gaps here are repair items, even in code that needs rebuilding elsewhere, and they are non-negotiable before real customers arrive. If access rules are tangled through the whole product and cannot be isolated, that adds weight to the rebuild side of the scale.
10. What would the next stretch cost on each path?
Forward cost is the time, money and risk needed to reach a product real customers can use, estimated separately for repair, partial rebuild and rewrite. Money already spent is irrelevant to this comparison. Choose the path with the lowest total cost to a usable release, adjusted for how reliable each estimate is.
How to check it
Give two independent developers or teams the same written brief and ask each for:
- A range, not a single figure, for each of the three paths
- The assumptions behind each range
- A first milestone that can be demonstrated in a short, fixed period
- What is included: testing, data migration, deployment and documentation
What the answer tells you
A wide range signals unknowns, so treat the spread as information. The cheapest rewrite quote is often the one that skipped data migration or testing. If two honest estimates still leave the choice close, take the path that produces a working milestone soonest, because it teaches you the most for the least money.
Scoring your answers: repair, partial rebuild or rewrite
To choose between repairing, partly rebuilding and rewriting a half-built MVP, mark each question green, amber or red, then read the groups. Clear the gate questions first, then count red answers among the foundation questions. A few localised reds suggest repair or a partial rebuild, while reds across structure, data and stack suggest a rewrite.
The table shows how much effort each question takes to answer and how much weight it carries in the decision.
| Question | Effort to answer | Weight in the decision | A red answer points toward |
|---|---|---|---|
| 1. Core user flow | Low | High | Repair, or rebuild one flow |
| 2. Builds and runs | Medium | High | Fix access first, then re-estimate |
| 3. Ownership | Low | High | Fix before deciding |
| 4. Readable code | Medium | High | Partial rebuild or rewrite |
| 5. Bug pattern | Medium | Medium | Partial rebuild |
| 6. Data model | High | High | Rebuild with careful data migration |
| 7. Code or plan | Low | High | Pause and settle scope first |
| 8. Technology stack | Low | Medium | Rebuild the affected parts |
| 9. Security basics | Medium | High | Repair first, then decide |
| 10. Forward cost | High | High | Breaks a close tie |
Two of the heaviest questions, ownership and scope, need no technical skill at all, so start there.
How to read your scorecard
Work through the groups in this order:
- Gate questions (2, 3 and 7). Resolve any red before choosing a path. A product you cannot run, do not own or cannot define is unsafe to repair and unsafe to rewrite.
- Surface questions (1, 5 and 9). Reds here usually mean repair work, and security gaps get fixed first on any path.
- Foundation questions (4, 6 and 8). These decide the size of the job. Count the reds and note whether they sit in one module or across the whole product.
- Cost question (10). Use it to break ties, not to start the decision.
Choosing the path
- Repair when the foundation answers are mostly green and the bugs are scattered.
- Partial rebuild when one or two foundation reds sit inside a single module, such as payments or syncing, and the rest holds up.
- Rewrite when structure, data model and stack score red together, fixes keep breaking other features and the scope now fits on one page.
Repair what is only unfinished. Rebuild what is structurally wrong. Rewrite only when the foundation is wrong and the plan is clear.
When a rewrite is the wrong answer
A rewrite disappoints when the real problem is unclear scope, when the old data has no export plan, or when the urge comes from distrust of a departed developer rather than evidence. It also disappoints when a new team starts without the old team's notes. Carry over every screen, flow, data export and written decision that still holds.
When you can run this without outside help
A founder with a technical co-founder or a trusted senior developer, clean ownership and a one-page scope can usually work through these questions alone. The only outside input needed may be a paid day of independent code review.
When outside help earns its place
Bring in a partner when nobody on your side reads code, when two advisers give conflicting verdicts, when the data model is the problem, or when the product handles payments or sensitive data and needs a careful security pass.
Bring your ten answers to a second pair of eyes
Share your scorecard and we will help you test whether repair, partial rebuild or rewrite fits your product and runway.
Pressure-test your planHow KSoft Technologies Helps With a Stalled MVP
We work with founders on MVP and product development, and a stalled build is a common starting point. The most useful first piece of work is often the one this article describes: a short, written review of ownership, structure, data and scope, done before anyone commits to a repair or a rewrite.
Depending on what that review shows, we can help you test the three paths against your runway, size a first milestone you can demonstrate, or scope a partial rebuild around the weakest module. If your own team or a freelancer can finish the job, we will say so.
If you would like to talk through your repair-or-rewrite options, we can start from your ten answers. More from our team is on the KSoft Technologies YouTube channel.
Decide on evidence, then fund only the first milestone
Every question above reduces to one test: does this path get real customers onto a working product with the least unverified risk? Spending history does not answer that, and neither does trust or distrust of the person who left. Ownership, a running build, a one-page scope and a readable structure do.
Most half-built MVPs are not beyond saving, and not all deserve saving. The ones worth repairing tend to have sound data and scattered bugs. The ones worth rewriting tend to have the opposite, along with a founder who can now say what the product should do.
A sensible next step takes one afternoon. List every account and who holds the login, write the one-page scope, and ask an independent developer to start the code on a clean machine. Those three results answer your gate questions and make every later estimate more honest.
Once the gates are clear, choose a path and fund only the first milestone, with a demonstration at the end of it. If the milestone slips, you have learned something early and the decision can change.
Pick a path, then fund it in stages
A clear decision and a first checkpoint keep the next phase honest. Talk to us about the safest place to start.
Choose your pathFrequently Asked Questions
What does it mean to rewrite an MVP instead of repairing it?
Repairing keeps the existing code and fixes or finishes it. Rewriting builds a new codebase, usually carrying over the designs, user research and exported data from the old one. The difference is what survives. Repair preserves the code, while a rewrite preserves only the knowledge, which is why it needs a clear scope before it starts.
Why do MVPs stall halfway through the build?
The common causes are shifting scope, unclear priorities, a single developer with no review, and money or attention running out before the first release. Technical difficulty is rarer than founders assume. Most stalls begin as product decisions that nobody settled, then show up later as late, buggy or abandoned code.
Why do rewrites often run late as well?
A rewrite has to rebuild everything the old product quietly did, including edge cases nobody wrote down, data migration and testing. Teams estimate the visible features and underestimate those hidden ones. Rewrites also attract new feature ideas, so scope grows. Fixing the scope list before starting is the best defence.
What does a stalled MVP cost a business besides money?
Time to market is the largest hidden cost, because competitors and customer feedback move on while the product waits. Other costs include lost team morale, delayed investor conversations, early users who tried a buggy version and left, and founder attention spent managing a project instead of selling. These are hard to price but real.
Can I judge the quality of my MVP's code without being technical?
You can judge the signals, even if not the code. Check whether the app runs for a new developer, whether you own every account, whether fixes keep breaking other features and whether the developer left written notes. For the code itself, pay an independent developer for a short review rather than relying on the builder's opinion.
Is a partial rebuild safer than a full rewrite?
Often, when problems cluster in one or two modules. Replacing a single weak area keeps working features in place and limits the amount of new code to test. It is riskier when old and new parts must share a poor data model, because the new code inherits the old design's limits.
Can a new developer take over code another developer left?
Usually yes, if the code runs, the accounts are transferred and the structure is readable. A good developer will want a day or two to explore before estimating. Handover is harder when there are no tests, no notes and secrets stored on one machine. Allow time for investigation, and budget for it separately.
When should I stop spending on a half-built MVP?
Pause spending when you cannot say what the product must do, when you do not control the accounts, or when fixes keep creating new bugs. Resume once those three are resolved and a first milestone is defined. A pause of a few weeks to gather facts usually costs less than another stretch of unplanned work.
How do I get an independent code review of my MVP?
Ask a developer or small firm with no stake in building the next phase to review the repository for a fixed fee and a fixed time. Give them read access, your one-page scope and your ten answers. Ask for a written report on structure, data model, security and a rough view of each path.
How much does it cost to repair or rewrite an MVP?
It depends on scope, code quality, data complexity, integrations, testing needs and the team you hire. No honest figure exists without looking at the code. Ask for ranges with stated assumptions for repair, partial rebuild and rewrite, and be cautious of any quote that leaves out testing, data migration or deployment.
How long does a rewrite take compared with a repair?
A repair usually reaches a usable release sooner, because the working parts already exist. A rewrite takes longer to show visible progress, since foundations come first. The honest comparison is time to a first usable release, not time to finish everything. Ask each path to name a milestone you can demo in stages.
Should I hire a freelancer or an agency to finish a half-built MVP?
A freelancer suits a well-defined repair with a reviewed scope and someone on your side who can judge the work. A team suits a partial rebuild or rewrite that needs design, testing, deployment and continuity if one person leaves. Whichever you choose, insist on code you own, written handover notes and staged payments.
