Rescuing a broken prototype and rebuilding it as real code usually costs between €12,000 and €20,000 with me, at a fixed price, in two to four weeks. The number depends mostly on how many distinct workflows your app has, how much of it was never written down, and what has to be migrated: users, data, payments. I'm Hanad Kubat, a senior software engineer in Vienna, and the rescue rebuild is one of the three kinds of work I do. Below is how the price is built, what pushes it up or down, and how to tell whether you need a rebuild at all.
Key Takeaways
- My rescue rebuilds run €12,000 to €20,000, fixed price, two to four weeks. A first build from scratch starts at €12,000.
- A €1,500 Prototype Audit (3 to 5 days) tells you whether to repair or rebuild before you commit. It is credited against the build.
- The biggest cost driver is usually not messy code. It is that nobody has written down what the app is supposed to do.
- A fixed quote is only trustworthy after someone has actually read your prototype. Quotes given from a screenshot are guesses.
- Prices stay low because it is one senior engineer: no agency overhead, no project-manager layer, no offshore markup.
Table of Contents
- What a rescue rebuild costs
- Why a rebuild is not the same as starting over
- What moves the price up or down
- Repair, extend or rebuild: how to decide
- How to estimate your rebuild before you ask for quotes
- What a proper assessment covers
- Freelancer, agency or fixed-price: where the cost risk sits
- Mistakes that make a rescue more expensive
- Where my rescue work fits
- Perspective
- FAQ
- Sources
What a rescue rebuild costs
Here is the range, stated plainly, with what sits behind each figure.
| What you need | Price | Timeline |
|---|---|---|
| Prototype Audit: a read of your prototype with a written verdict and a scoped quote | €1,500, credited against the build | 3 to 5 days |
| First real version of a product (no code yet, or a Figma file) | from €12,000 | 2 to 4 weeks |
| Rescue rebuild of a Lovable, Bolt, v0, Replit, Cursor, Bubble, Softr or Glide prototype | €12,000 to €20,000 | 2 to 4 weeks |
| Continuation retainer after launch | optional | ongoing |
Those are my prices as published on my site. You will see other figures online. Some articles put rebuilds of AI-built apps in the tens or hundreds of thousands of dollars. Those numbers describe large, long-running projects with agency teams, and they are not what a focused two-to-four-week rebuild of one product looks like. I'm not going to pretend my price is the market price. It is what one senior engineer charges when he does the work himself.
Why is it possible? Because the price has no layers in it. There is no account manager, no project manager translating between you and the developer, and no offshore markup on top of someone else's hourly rate. The person you speak to writes the code.

Why a rebuild is not the same as starting over
A founder who has a running prototype has already done the most expensive part of a software project: working out what to build. The prototype validated the idea. Real users or real investors have seen it. That is why I treat the prototype as the specification.
In a rescue, I read what exists, including every screen, every flow and every odd behavior your users depend on. Then I rebuild it as maintainable code that a normal developer can pick up later. The stack is deliberately boring and widely known: TypeScript, Next.js, React, Node, SQL, Stripe and Cloudflare Workers. Boring matters for cost. If your next hire needs a specialist to touch the code, you pay for that specialist every time.
The code is yours from the first commit. You see working progress before you pay for it in full, so the money does not disappear into a black box for a month.
What moves the price up or down
Two rebuilds can differ by thousands of euros for reasons that have nothing to do with how good the prototype looks. These are the factors that matter, roughly in order.
1. How much of the app is written down
The most expensive thing in a rebuild is rarely the typing. It is working out what the app is meant to do. One recent write-up on rebuilds of AI-assisted apps makes the same argument: the cost comes less from bad code than from the fact that nobody can say what the app was supposed to do, so an engineer has to reverse-engineer a missing specification.
You can shrink that cost before anyone quotes you. Write down the core flows, the edge cases you know about, and what "working" means for each. One page per workflow is enough. A prototype with a clear owner who can answer questions is cheaper to rebuild than one where the person who built it has left.
2. The number of distinct workflows
A tool with one core workflow, say onboarding a client, generating a document and charging for it, sits at the low end. An app with a customer side, an admin side, role permissions and three integrations sits at the high end. Count workflows, not screens. Screens are cheap. Workflows carry logic.
3. Logins, roles and payments
These are where prototypes break first, and they are where a rebuild has to be careful. Real authentication, permissions that actually keep one customer's data away from another, and Stripe billing that handles failed payments, refunds and renewals take real engineering time. If your prototype fakes any of these, expect them to be rebuilt, not ported.
4. Data migration
If you have live users and records in a no-code database, they have to move without loss. A prototype with test data only is simple. A Bubble app with two years of customer records is not. Migration also involves deciding what to clean up on the way, and that is a decision I'll put in front of you, not make silently.
5. Platform lock-in
Bubble, Softr and Glide keep logic inside the platform. There is no code to read, so the logic has to be recovered from behavior and screens. A Lovable or Bolt project at least exports code, but exported code is often a tangle of generated files that no one planned. Either way, the prototype is the guide, not the foundation.
6. Security and review requirements
If an investor, an enterprise customer or a regulator will review your system, the rebuild has to survive that review. That means access control, secrets handling, logging and a clear data model. It adds scope, and it is much cheaper to build in than to bolt on. If a due diligence process is coming, my guide to the software due diligence checklist shows what reviewers look at, and technical due diligence explained for a CTO goes deeper.
Repair, extend or rebuild: how to decide

A rebuild is not always the right answer, and I'll tell you if it is not. Most of the time the decision comes down to a handful of questions.
Repair or extend the prototype when:
- It has a small number of users and the problems are cosmetic or isolated.
- The platform bill is reasonable and the platform does everything you need.
- You are still testing the idea and might change direction next month.
In that case, spending €12,000 or more is premature. My positioning is honest guidance if an off-the-shelf tool fits your need, and I would rather say so than sell you a build you do not need.
Rebuild when:
- The app breaks under real users, and every fix creates a new bug.
- Your build stalled around 70%: the last 30% (payments, permissions, edge cases) refuses to work however you prompt it.
- The platform bill has become absurd compared with what the product earns.
- A security review, an investor or a larger customer is coming and the prototype cannot pass it.
- You were handed code by an agency or freelancer and nobody else can read it.
A useful rule: if each new feature costs more than the last one, the structure is the problem, and patching the structure costs more than replacing it. For a bigger system that is already earning revenue, I wrote up how to rebuild a legacy SaaS without stopping the business.
How to estimate your rebuild before you ask for quotes
You do not need to be technical to do a useful first estimate. Do this in an afternoon.
- List the workflows. Write each thing a user does, start to finish, in one sentence: "A client uploads a document, I review it, they pay, they receive a signed PDF."
- Mark what is broken. Next to each, note whether it works, works sometimes or fails.
- Note the integrations. Payments, email, calendars, a CRM, an AI model. Each one is a separate piece of work.
- Count your live data. How many users and records exist, and where do they live?
- Write down the deadline and the reason. An investor demo in six weeks is a different job from "sometime this year."
- Give access. Share the prototype, the platform login or the exported code, and any design files.
With that, a rebuild estimate stops being guesswork. Without it, any number you are given is a placeholder.
What a proper assessment covers
Before a developer quotes a rebuild, someone should read the prototype. That is what the Prototype Audit is: 3 to 5 days, €1,500, credited against the build if you go ahead with me. The point is that you pay for a verdict, not for a sales call. The audit covers:
- What exists. Screens, flows, data model and integrations, written down.
- What is broken or fragile. Where it fails under load, where permissions leak, where payments are unreliable.
- What the platform is costing. Monthly bills against what you would pay hosting real code.
- Repair or rebuild. A clear recommendation, with reasons.
- A fixed scope and price. If a rebuild is the answer, you get the scope in writing and the price before anything starts.
The value of the audit is that the later fixed price is based on reading your actual app. It is the reason I can quote a price and keep to it.
Freelancer, agency or fixed-price: where the cost risk sits
First-time founders often compare three ways to hire. The cost risk is different in each.
| Type | How you pay | Where the risk sits |
|---|---|---|
| Hourly freelancer | Time spent | You carry the risk: the bill grows if the scope does, and you have to manage the work |
| Agency | Often a larger project fee or day rates | Overhead for account and project management is included in the price, and the person you brief is often not the one who codes |
| Fixed-price senior engineer (my model) | One price for a defined scope | The price is agreed upfront and the person you talk to builds it |
The agency route is where I see the most painful stories described by founders: a large invoice, a team that changed halfway, and a codebase nobody else can read. A fixed price with a senior engineer who does the work himself removes the two things that inflate cost: layers and open-ended hours. You also see working progress along the way, and you own the code from the first commit, so you are never held hostage by the person who wrote it.
Mistakes that make a rescue more expensive
- Adding features during the rebuild. Rebuild first, extend after. Mixing both is the fastest way to lose a fixed scope.
- Not having one decision-maker. Two people with different opinions on how a workflow should behave cost days.
- Hiding known problems. If you know payments sometimes double-charge, say so. It is cheaper to price than to discover.
- Rebuilding on the same platform. If the platform is what hit the wall, re-prompting does not help.
- Ignoring handoff. Code that only its author can read is the most expensive code to own. Plain, widely known tools keep the next developer's bill low.
If the rebuild includes AI features, build in safeguards from the beginning. My notes on AI guardrails for SaaS founders cover what to put in place.
Where my rescue work fits
I do exactly three kinds of work: rescuing or rebuilding a prototype, building a first real version, and turning one painful manual workflow into an internal tool. If your Lovable, Bolt, Bubble or similar prototype ran well enough to validate the idea and has now hit a wall, the rescue rebuild is for you. The prototype becomes the specification, and you get maintainable code you own.
Builds start from €12,000 and rescue rebuilds run €12,000 to €20,000. You can start with the €1,500 audit, which is credited against the build, at hanadkubat.com.
Perspective
When a founder sends me a broken prototype, the first thing I say is that the work they already did has value. The prototype is a specification they paid for with real time, real users and real feedback. A rebuild does not throw it away. It turns it into something that can carry weight.
I keep my pricing public and my scope fixed because the alternative is a hidden meter running while you wait. I quote a price, say why it is possible, and do the work myself. No one sits between you and the person writing the code, and that is the main reason the cost stays where it is.
I also try to be honest when a rebuild is not needed. If a simpler tool covers your case, I will tell you. If it does not, I will build the thing properly, deploy it, hand it over and make sure the next developer can pick it up without me.
Hanad Kubat
FAQ
How much does it cost to rescue a Lovable or Bolt app?
With me, a rescue rebuild costs €12,000 to €20,000 at a fixed price and takes two to four weeks. Where your app lands depends on the number of workflows, the state of logins and payments, and how much data has to be migrated. The €1,500 Prototype Audit gives you the exact scope and price first.
Is it cheaper to fix the prototype than to rebuild?
Sometimes. If the app has few users, the problems are isolated and the platform bill is low, repairing is cheaper. If every fix breaks something else, or you are heading into an investor or security review, the structure itself is the problem and a rebuild costs less than repeated patching.
Can you give a rebuild estimate without seeing the code?
Only a rough range. A trustworthy fixed price needs someone to read the prototype and understand its workflows, data and integrations. That is the purpose of the audit: 3 to 5 days, €1,500, credited against the build if you continue.
Do I own the code after a rebuild?
Yes. You own the code from the first commit. It is written in widely known tools (TypeScript, Next.js, React, Node and SQL), so any competent developer can take it over later.
What should I prepare before asking for a quote?
List your core workflows in plain sentences, note which ones fail, name the integrations and count your live users and records. Share access to the prototype and any design files. The more that is written down, the less time is spent reverse-engineering and the lower the cost.
