What Does It Cost to Build a Prototype?
A clickable Figma prototype typically costs SEK 50,000–150,000 and shows the experience and flow without a line of code. A coded prototype costs SEK 150,000–400,000 and also proves technical feasibility. The choice depends on what needs proving and how much of the work can carry over to the next phase.
A prototype is the cheapest way to make an idea concrete enough to test – but “prototype” means two different things with two different price tags. The clickable version shows how the product feels; the coded version proves it can be built. Here’s what they cost and how to choose the right level.
Two levels, two price tags
| Prototype type | Typical cost | Time required |
|---|---|---|
| Clickable Figma prototype | SEK 50,000–150,000 | 2–4 weeks |
| Coded prototype | SEK 150,000–400,000 | 4–8 weeks |
Within each range, scope is what drives the price: the number of screens and flows, how polished the design needs to be, and – for the coded version – how much real data and integration the test needs to be meaningful.
What the clickable prototype proves
A Figma prototype is linked-together screens that look and feel like a real product. It answers questions about experience and flow: do users understand what the service does? Can they find their way around? Does it feel worth paying for? It works great in user interviews, sales meetings, and investor presentations.
Its strength is iteration speed – a flow can be redesigned between two interviews on the same day. The limitation is just as clear: there’s nothing behind the screens. It can’t handle real data, can’t test performance, and can’t prove the technology holds up.
What the coded prototype proves
A coded prototype is real software, scoped to just what needs proving. It answers questions about technical feasibility: can the data actually be pulled from the source system? Does the algorithm hold up under real load? Does the integration work the way the vendor promises? It can also be put in the hands of a small group of real users, which produces behavioral data the clickable version never reaches.
The price is exactly that – two to three times the clickable version – with slower iteration. That’s why a coded prototype should be used when the uncertainty is genuinely technical, not as a more expensive way to test design.
Reusability: the calculation factor many miss
A prototype’s real cost is the price minus the value of what carries forward into the next phase. That’s where the two levels diverge:
- The Figma prototype gets reused almost every time. Flows, screens, and components become design groundwork for the MVP and can shorten its design phase by weeks. There’s no code – but that was never the promise.
- The coded prototype can be reused – if it’s built in the stack the product will live in, and with reasonable care. Built as a quick experiment, it’s often cheaper to rewrite than to clean up, and forcing sloppy prototype code into production is a classic way to buy technical debt from day one.
So make the decision up front: is this a one-off experiment (build it as fast as possible, then throw it away) or the foundation of the product (build it in the right tech, accept a somewhat higher price)? Both are right in different situations – the expensive part is not choosing.
Worked example: net prototype cost
A company builds a Figma prototype for SEK 90,000, runs two rounds of interviews, and lands on a validated flow. When the MVP is later built, the design gets reused directly, shortening the design work by an estimated two weeks – worth somewhere in the range of SEK 80,000–100,000. The prototype’s net cost was therefore close to zero, while it eliminated the risk of building the wrong flow for hundreds of thousands of kronor. That’s the point of the prototype calculation: the price is on the invoice, but the value lies in what it prevents and what it passes on.
How to choose a level
If the biggest uncertainty is in the experience or the business case, start with Figma. If it’s in the technology, code the critical assumption and nothing more. If both are uncertain, do Figma first, then a narrow technical prototype for whatever still doesn’t sit right.
Two check questions help along the way. What’s the most expensive mistake we could make in the next phase – and does the prototype actually test for that? And who needs to be convinced – users, investors, or your own tech team? Users and investors respond to visuals; the tech team only responds to code. At Weapp we build both levels, either as a standalone engagement or as the start of a product journey – get in touch if you’d like a proposed approach for your idea.
Frequently asked questions
What's the difference between a prototype and an MVP?
The prototype exists to persuade and to learn – it's tested in interviews, demos, and investor meetings but never goes live. An MVP is a real product in production with real users, scoped to one core flow. The prototype comes before the MVP and costs a fraction as much.
Can a Figma prototype be used in investor meetings?
Yes, that's one of its most common uses. A well-crafted clickable prototype makes the idea concrete and shows the team can execute, at a tenth of the cost of building the real thing. Just be clear about what it is – investors who think the product is already built won't be happy in due diligence.
Is the coded prototype always thrown away afterward?
No, but plan as if it could be. If it's built in a stack that carries forward, and with reasonable care, parts of it can be reused in the MVP. If it's built as fast as possible to test one assumption, rewriting is often cheaper than cleaning up – and that's completely fine, as long as the decision was made deliberately from the start.
Who builds the prototype – a designer or a developer?
A clickable Figma prototype is built mainly by a designer, often with a strategist supporting the flows. A coded prototype needs developers, ideally with the designer still in the loop. That's one reason for the price gap – the coded version keeps more disciplines busy for longer.
How many users should test the prototype?
Five to eight people per test round is usually enough for patterns to emerge. Better to run two or three small rounds with redesigns in between than one big one – the prototype's strength is precisely that it can change within hours between tests.