From AI prototype to sellable product: the industrialisation method

You have a prototype that works. A demo that gets a "wow" in a meeting, something you built yourself with an AI tool, some no-code or three evenings of coding. People have tried it, some are ready to pay. And now you face the real question: how do you industrialise a prototype without breaking everything or starting over from scratch?

This is the trickiest moment of a product. You have validated the idea, but what runs today is not sellable yet. This article is the method I apply at AsuOs to go from prototype to product. No theory, just what works in the field.

Your prototype is not your product, and that is good news

First thing to take on board: a validated prototype is a functional specification, not a production codebase.

That may sound harsh, but it is freeing. Your prototype has done its job. It answered the only question that mattered at the start: does anyone actually want this? Answer, yes. Now it becomes the best set of requirements you could hope for. Every screen, every field, every button tells the story of a decision you already made and validated with real users.

The trap is believing you just need to "clean up" the prototype to make it solid. No. A prototype is optimised to move fast and prove an idea. A product is optimised to last, to handle users, to protect data and to evolve without breaking. Those are not the same goals, so not necessarily the same code.

The good news: you are not starting from nothing. You are starting from a detailed map of the territory. That changes everything, both on speed and on budget.

Step 1: the audit, before touching any code

You never rewrite a prototype without understanding it first. The first step is an honest audit. At AsuOs it is even the front door of the From prototype to product offer, and I do it for free, because without it we move blind.

The audit answers four concrete questions.

What does the product really do?

We list the real user journeys, not the imagined ones. Often 80% of the value sits in two or three flows. The rest are features added "just in case" that never got used. We spot them right away.

What is it built on?

AI tool, no-code generator, home-made framework, improvised database. We look at what holds up and what is going to blow up at the first real traffic spike. A no-code prototype can hide deal-breaking platform limits, a vibe-coded prototype can hide gaping security holes.

Where are the risks?

Personal data stored any old way, API keys in plain text, no backup at all, dependence on a personal account. In Switzerland, with the nLPD, sloppy data handling is not a technical detail, it is a direct legal risk.

How much debt are we taking on?

By the end, I have a clear view of what to keep, what to patch up and what to throw away. That snapshot is what allows an honest quote, with no nasty surprise halfway through.

If your prototype comes from a no-code tool or a vibe coding session, I laid out the logic of taking one over in the article taking over a no-code or vibe-coded project. Here, we focus on the industrialisation method itself.

Step 2: what we keep, what we rebuild

This is the most strategic decision of the project. Keeping everything means dragging the prototype debt along for years. Throwing everything away means burning budget and time for nothing. The truth is always somewhere in the middle.

What we almost always keep:

• The design and the interface, if the prototype was done with care. Validated screens are gold.
• The business logic, the rules, the edge cases discovered while testing. That is your real knowledge.
• The content, texts, reference data already entered.

What we almost always rebuild:

• The data layer. A well-thought-out database from the start saves months of pain later.
• User and access management. Too critical to be cobbled together.
• Everything to do with security and payments.

Between the two, there is a grey zone that we settle case by case. The rule I hold myself to: we only rebuild a piece if keeping the prototype version costs more in the medium term than doing it properly now. No rewrite on principle, no keeping things out of laziness.

Step 3: laying the foundations

Here is the heart of industrialisation work. A prototype stands up because it carries little. A product has to hold under load, over time, with several people working on it. That rests on five foundations.

A clear architecture

We separate responsibilities: interface, business logic, data access. In a prototype, everything is often mixed together, which makes the slightest change risky. A clean architecture is what lets you add a feature in six months without praying that nothing breaks elsewhere.

A real database

No more spreadsheet used as a database or improvised storage from the no-code tool. We model the data properly, with relations, constraints and above all automatic backups. It is invisible to the user, but it is what keeps you from losing three months of data on a bad morning.

Security, from the start

Solid authentication, encrypted passwords, role-based permissions, protected sensitive data, nLPD compliance for a Swiss product. Security is not added at the end, it is designed into the foundations. It is far cheaper to lay it early than to patch up after an incident.

Automated tests

A prototype, you test by hand. A product with customers, you can no longer afford that. We write tests on the critical journeys: sign-up, payment, main actions. The day you change something, the tests tell you right away if you broke something. It is your safety net to move fast without breaking.

A CI/CD pipeline

Every change automatically goes through the tests, then deploys cleanly. No more stressful manual release on a Friday night. You push your code, the machine checks and deploys. That discipline is what separates a project that moves forward from one that spins in circles fixing bugs.

Step 4: industrialise without breaking everything

The big fear, when you want to go from prototype to product, is the "big bang": rewrite everything for six months, then switch over and pray. I do not work that way, it is too risky.

The method is progressive. We build the new foundations next to the prototype, we migrate the pieces one by one, always keeping something functional. At each step, you have a product that works, a bit more solid than the day before.

In practice, we often start with the data layer and authentication, because everything else depends on them. Then we rebuild the critical journeys one by one. The prototype can even keep running for some uses while we stabilise the rest. The goal is never a big switchover day, it is a series of small safe steps.

This approach has another advantage: you see the product firm up continuously. You stay in control, you can readjust priorities, and the budget stays under control because we deliver in usable chunks.

How long, how much does it cost?

The real answer: it depends on the audit. A clean prototype, well thought out even if it is not solid, industrialises fast. A fragile prototype, with questionable early choices, needs more rebuilding.

What I can say is that starting from a validated prototype almost always costs less than starting from a blank page. You have already paid for the most uncertain part: finding out what users want. Industrialisation is engineering, so something far more predictable than product exploration.

The bad move is wanting to sell the prototype as is to "save time". You save a few weeks and you lose months in incidents, lost data and disappointed customers. A product that crashes in front of a real customer costs infinitely more than foundations laid properly.

Where to start

If you have a prototype that works and people ready to pay, you are exactly in the right place. The logical next step is the audit: understanding what you really have in hand before deciding anything.

That is what I offer for free in the From prototype to product package. We look at your prototype together, I tell you honestly what to keep, what to rebuild and how much that represents. No commitment, and at the very least you will walk away with a clear view of your path to a sellable product.