Why we build a free prototype first

We build a free, clickable prototype of your product before you sign anything or pay anything. No contract, no obligation. If you look at it and walk away, you owe us nothing.

That sounds risky for us and safe for you. That is roughly right, and we still do it. Here is why, and how it works.

What is wrong with the normal way?

Most software projects start with a leap of faith.

You describe what you want. A company nods, sends a quote, and asks you to sign. Then you both find out, weeks and a large invoice later, whether you were even picturing the same thing.

Words are a terrible way to agree on a product. "A simple booking page" means five different things to five different people. Everyone in the room nods, everyone pictures something different, and nobody finds out until it is built.

That gap is the single most expensive thing in software. Not the code. Not the hosting. The misunderstanding that survives all the way to launch.

How does a prototype fix it?

A prototype turns an argument about words into a conversation about a thing.

Instead of you describing a screen and us imagining it, you click the screen. You notice the button is in the wrong place. You realise you forgot to mention the second user type. You see what is missing in ten minutes, not ten weeks.

That is not a small saving. Changing a design costs an hour. Changing a built product costs days, sometimes weeks, and often means undoing work that was done correctly to the wrong brief.

The loop matters. You react, we adjust, you react again. By the time we quote, we are quoting on something you have actually seen.

What do you actually get?

A clickable design of your core product. Not a slide deck, not a wireframe sketch on a call.

It covers the key screens and the main flow, the parts that decide whether the product works. It is built around your idea, not a template with your logo dropped on top.

You can open it, click through it, and show it to a colleague or an investor. Most founders find that last part more useful than they expected.

What it is not: a working product. There is no database behind it, no accounts, no payments. It is the shape of the thing, made real enough to judge.

That split is deliberate. The prototype exists to settle what the product is, quickly and cheaply. Everything on the right-hand side is real work that belongs in the build, once we both agree on what we are building.

Why give it away free?

Four reasons, and none of them are charity.

It kills the expensive misunderstanding early. Before anyone commits money, we both find out whether we are picturing the same product. That is worth more to us than the hours it costs.

It replaces a sales pitch with proof. You judge the work, not a promise. We would rather be measured on something we made than on how well we present.

It lets us quote honestly. When you cannot see a project clearly, you pad the estimate to cover the risk. That padding is real money and you pay it. Seeing the product first means we can scope it accurately, which is why we can offer one fixed quote instead of an hourly rate.

It filters out wrong-fit projects. Some projects are not right for us, and some clients are better served elsewhere. Finding that out during a free prototype is far better for both sides than finding out mid-build.

What happens after the prototype?

Five steps, and you can stop after any of them.

The handover step is the one people underestimate. Everything ships to your own accounts. You receive the code, the repositories, the credentials, and the keys. Nothing runs on our infrastructure, and there is no lock-in.

We wrote separately about why that matters, because it is the thing founders most often discover too late.

Is there a catch?

Not really, but there are honest limits worth stating.

A prototype is design, not engineering. It shows what the product does, not how fast it will run or how it handles ten thousand users. Those are real questions, and we answer them in the scoping conversation, not in the prototype.

It also is not unlimited. We build the core of your product, not every screen of a fifty-screen platform. The goal is to make the important decisions visible, not to design the whole thing for free.

And we do not build prototypes for projects we do not think we should take. If your idea needs a permanent in-house team, or a specialism we do not have, we will say so at the first conversation rather than spend your time.

Frequently asked questions

Is the free prototype really free?

Yes. No contract, no deposit, no obligation. If you look at it and decide not to go ahead, you owe us nothing and we part on good terms. We build it because it makes our quotes more accurate, which is worth the hours to us.

How long does a free prototype take?

Usually a few days from the first conversation, depending on how clear the idea is and how many screens the core flow needs. We will tell you the timeline before we start, so you are not waiting without a date.

Do I own the prototype?

Yes. It is a design of your product idea, and it is yours. If you take it to another developer, that is your right. We would rather be chosen than locked in.

What do you need from me to start?

A short description of what you want to build and who it is for. That is genuinely enough to begin. If we need more detail we will ask specific questions rather than send you a long form to fill in.

What if I do not like the prototype?

Tell us why, and we will adjust it. That is what the second step is for. If it still is not right after that, we are probably not the right fit for the project, and finding that out for free is exactly what this process is designed to do.

Does a prototype guarantee the final price?

It makes the quote far more accurate, because we are pricing something we can both see. Once the scope is agreed in writing, the price is fixed. Anything beyond that scope gets quoted before it is built, so there are no surprise change fees.

The short version

We would rather show you the work than describe it. A free prototype costs us some hours and saves both of us the most expensive mistake in software: building the wrong thing correctly.

You get a real thing to judge. We get an accurate picture to quote against. Nobody signs anything until both of those exist.