Clickable Prototype or Code Prototype? Decide in 4 minutes
Clickable Figma prototype or working code? The format choice decides weeks of effort and thousands of euros — and the answer is almost never „both“. We build both formats and show you when each pays off.
The choice follows the question you need answered — not the budget. A clickable prototype (Figma) tells you whether people understand the interface and complete the flow: in days, without code. A code prototype tells you whether the thing holds up technically: real data, real integrations, real load. If the risk sits in usability, build the clickable one. If it sits in the technology, build code. If it sits in both: clickable first, then code.
You have an idea, a rough sketch, and a gut feeling that it might work. Now the question: do we build a clickable Figma prototype or jump straight to something that actually runs?
This decision costs time and money, and in the wrong case your faith in the idea, because you answered the wrong question.
We've built both formats since founding. That's exactly why we have nothing to sell here — we recommend what fits your question. Below, the logic we use ourselves.
TL;DR — the 5 key points
- The question is never „which format is better?“ — but „which risk do we want to validate?“. The format follows from that.
- Desirability + usability → a clickable prototype is enough. Feasibility + viability → a code prototype is usually mandatory.
- A clickable prototype is always throwaway material. A code prototype goes to production with re-implementation — we design it that way.
- At decivo: Clickable Prototype from €3,500, Code Prototype from €12,500, both as fixed net prices.
- If you build the code prototype with Lovable, Bolt or Base44: in the decivo AI App Radar, 81% (367 of 454) of AI-built DACH apps needed rework before launch. Check before real user data goes in.
What are we actually comparing?
Before we decide, we need to agree on what we're talking about. Clickable prototype and code prototype are often used interchangeably in marketing — but they are two very different tools.
Clickable Prototype
A clickable prototype is a set of static screens linked to feel like a real app. Tap „Book“ and it jumps to a confirmation screen — but nothing happens behind it. No database, no logic, no persistence. Tools: Figma, Figma Make, Penpot or ProtoPie.
- Strength: fast to build, cheap to change, perfect for user tests.
- Weakness: can't answer technical questions and never goes to production.
Short definition: Clickable Prototype in the glossary.
Code Prototype
A code prototype is a small working application with real logic, real data, and a real deploy on a secure URL. Click „Book“ and something is written to a database. Tools: Next.js, Supabase, Vercel — augmented by AI tooling like Cursor and Claude Code.
- Strength: shows technical feasibility, surfaces edge cases, can become production with re-implementation.
- Weakness: more expensive and slower than a clickable — and overkill for pure acceptance questions.
Short definition: Code Prototype in the glossary.
Where it sits: wireframe, MVP, final product
A wireframe is static (no linking). An MVP is live, has paying users or a conversion target, and is widely distributed. The final product is scalable, maintained, CI/CD-ready. Clickable and code prototype both sit before the MVP — they're validation tools, not the product itself. Definition: what is an MVP?
Side-by-side
| Dimension | Clickable prototype | Code prototype |
|---|---|---|
| What it is | Linked screens, simulated interaction. No logic, no real data. | Working mini-application with real logic, real data, real deploy. |
| What you test | Acceptance, comprehension, flow logic. | Technical feasibility, performance, real data behaviour. |
| What you don't test | Speed, security, real-data edge cases. | Pixel polish, final microcopy, brand detail. |
| Typical tools | Figma, Figma Make, Penpot, ProtoPie. | Next.js, Supabase, Cursor, Claude Code; as a starting point also Lovable or Bolt. |
| Tool cost, do it yourself | Figma Starter free, Professional $16 per seat and month. | AI editor or app builder from roughly $8 to $25 a month, plus hosting. |
| Fixed price at decivo | Clickable Prototype from €3,500 net. | Code Prototype from €12,500 net. |
| Does it ship to production? | No — a clickable prototype is always throwaway material. | With re-implementation on a clean architecture: yes. |
Which risk do you want to validate?
The most useful question comes from product management: Marty Cagan (SVPG) distinguishes four big risks every product carries. Before any format decision, ask: which assumption do I want to test? Each risk has a matching format.
Desirability
Do users actually want this?
If someone enthusiastically taps „Book now“ on a clickable prototype, they would do the same in the real product. Real code adds nothing to this question.
Usability
Can they figure it out without help?
Comprehension shows up in click paths, not backend latencies. A moderated user test with five participants on a clickable prototype gives you clear insights.
Feasibility
Does this work technically inside the timeline we have in mind?
Performance, API behaviour, database logic, auth complexity — none of these can be answered by a clickable prototype. You need real code that surfaces real problems.
Viability
Does this make economic sense?
If you want to test conversion data or willingness to pay, you need code that handles real transactions. If you only need the story for an investor pitch, a strong deck with a clickable prototype can be enough.
In practice: write down the hypothesis that keeps you up at night. If it starts with „do they want this?“ or „can they figure this out?“ → clickable. If it's „is this technically possible?“ or „does this make economic sense?“ → usually code.
More on validation in practice: 6 validation methods that work.
Decision matrix: pick a format in 30 seconds
Risk and validation depth span a matrix. Depending on which quadrant you land in, the format recommendation changes — and with it the matching decivo module.
Which format fits your quadrant?
Walk through the axes: left to right is technical risk, bottom to top is desired validation depth. Per quadrant: the format that demonstrably works — plus the matching decivo module.
Clickable Prototype
You're testing comprehension and acceptance — the tech concept is clear. A clickable prototype with moderated user tests gives you exactly the insights you need, no code effort.
Code Prototype
Technical risk is high and you need real validation data. Code pays off here, because otherwise you would run two clarification loops back to back.
Wireframes / pitch deck
You only need internal alignment or an investor pitch — no real user feedback. Skip the clickable prototype, go straight in with sketches.
Code prototype (spike)
A spike implementation of the one critical part: API integration, AI integration, performance. Everything around it stays a sketch. Fast, focused, honest.
Stuck between two quadrants? Pick the higher-risk format. A clickable prototype that doesn't answer a technical question costs you a second iteration. A code prototype that's technically too powerful only costs you money.
Five anti-patterns that regularly cost money in the industry
These patterns aren't only documented in AI-coding research — they've been documented across the entire prototyping industry for years. If one of these sounds familiar, that's the clarity signal before you pick a format.
1 — Code prototype out of excitement, not risk
If the hypothesis is „do users want this?“ and you still jump into code, you're paying for an expensive answer to a cheap question. Clarify first: what exactly do you want to learn that only code can show?
2 — Clickable prototype sold as „MVP“ for too long
A clickable prototype is a discussion artefact, not a product. Showing it as „MVP“ through three investor rounds backfires the moment someone asks technical depth questions. By then you need code.
3 — Tool choice before format choice
„We use Figma because everyone does“ or „Cursor because it's hot“ are tool decisions. The format question comes first: clickable or code? Tool comes after. Reversing the order means you build the wrong thing very efficiently.
4 — Hacking real data into a clickable prototype
Linking Excel sheets or third-party plug-ins for „real“ data into a clickable prototype turns it into a messy code prototype without the architecture benefits of real code. Pick a side.
5 — Code prototype without a deploy
A code prototype nobody can reach outside your laptop validates nothing. Deploying it to a secure URL is part of the definition — otherwise it stays a demo, not a validation tool.
When does the combination of both make sense?
In a smaller share of projects we recommend both formats combined, in this order:
Step 1 — clickable prototype
You clarify acceptance, flow, and visual language. Three to five moderated user tests, one iteration round, done. Investment at decivo: from €3,500 plus €1,350 per test loop.
Step 2 — code prototype on top of the insights
Once the clickable is validated, it becomes a code prototype that surfaces the technically risky part. Advantage: you save the discovery phase in code, because the concept is already locked.
This combination makes sense when your project carries both a consumer-acceptance risk and a technical risk — and you want to clarify the consumer side before you invest in code. In most other cases, one of the two formats is enough.
Tooling for the technical side: MVP tools 2026 compared.
Code prototypes with Lovable, Bolt and co.: fast, but not unchecked
In 2026 a code prototype often no longer starts in an editor but in an app builder's prompt window. For the feasibility question that's legitimate: you quickly see whether the core logic holds. The catch comes as soon as real people sign up and enter real data. From then on the prototype is legally and technically a real app.
Our AI App Radar checks AI-built apps with a DACH connection from the outside. In the run “Panel 2026-10-01” (454 apps, methodology 2026.33), 18% (83 of 454) got Go and 81% (367 of 454) needed rework. The most common patterns are exactly the ones a prototype carries along:
- In 24% (109 of 454) the browser wrote straight to the database. Whether that's safe depends entirely on the access rules (Row Level Security).
- In 13% (57 of 454) a role comparison (such as role === 'admin') sat in the shipped JavaScript. Whether the server checks the role again is invisible to an outside scan; that is where the decision belongs.
- 98% (444 of 454) had no Content Security Policy, 36% (165 of 454) loaded Google Fonts from Google's servers at runtime.
For the format decision this means: an AI-built code prototype is a good way to test feasibility. Before real user data flows in, a check belongs in the plan. The free decivo Scan does it from the outside; the figures above are open in the AI App Radar DACH. What Row Level Security means is explained in our glossary.
How we settle the format decision with you
If you've looked at the matrix above and you're still not sure, the free discovery call is often enough. If the idea itself is still open, the Innovation Workshop is the right frame: it ends with a clickable prototype.
In the workshop we work out hypothesis, risk and validation depth together, look at your technical reality (existing stack, data sources, login and permissions) and settle on the format that fits your specific question, including a prioritised list of next steps.
Why this works: because we build both clickable and code prototypes ourselves, we have no commercial pressure to push one variant. If a clickable is enough, we say so. If you need code, we say that too — and ship both from one team.
- Innovation Workshop: €7,500 · sharpen the idea, define the first version, Clickable Prototype included · may be eligible for funding depending on location.
- Clickable Prototype: €3,500 · requirements become clickable user flows in the browser.
- Code Prototype: €12,500 · validated core features as working, tested software.
- UX Validation Loop: €1,350 per loop · extend the prototype and test it with users.
If you want to start straight away: a 30-minute discovery call is enough for us to give an honest format recommendation — even if the answer is „you don't (yet) need either“. See all modules.
What the whole path to an MVP would cost is worked out by the MVP cost calculator. For start-ups in North Rhine-Westphalia, the Go-to-Market voucher NRW can fund external services for a prototype, such as design, UI/UX and software.
Sources
Prices from the vendors' pages, retrieved on 20 Oct 2026. The radar figures are our own data (CC-BY 4.0); methodology and earlier runs are on the radar page.
Frequently asked questions on clickable vs. code prototype
What's the difference between a clickable prototype and a code prototype?
A clickable prototype is a linked set of screens in tools like Figma. It simulates interaction but has no real logic and no real data. A code prototype is a working mini-application with real logic, a real database and a deploy. The clickable prototype mainly tests comprehension and acceptance; the code prototype additionally tests performance, technical feasibility and how real data behaves.
When is a clickable prototype enough?
When you're testing acceptance, comprehension or flow: desirability and usability risks. Clickable prototypes deliver the same insights as code here, because users don't need to know whether real logic or just a link sits behind the button. According to Nielsen Norman Group, five test participants already uncover most usability problems in a flow.
When do you absolutely need a code prototype?
As soon as technical risk enters the picture: performance, AI integration, complex interfaces, real-time data or large data volumes. A code prototype is also mandatory if you want to test conversion or willingness to pay with real transactions. Then, however, the obligations of a real app apply too: data protection, access control, legal notice.
What does a clickable prototype cost in 2026?
Built yourself, Figma costs nothing on the Starter plan and $16 per seat and month on Professional (as of October 2026), plus your time. At decivo the Clickable Prototype costs from €3,500 net as a fixed price, the Innovation Workshop including a prototype from €7,500. What the whole path from prototype to finished MVP costs is shown by our MVP cost calculator.
Can the code prototype later become production?
With re-implementation on a clean architecture: yes. We build the code prototype so that the validated specification can be carried into a production codebase. Without that step it stays a validation tool. That's more honest than “prototype becomes product”, which in practice often ends in technical debt. For AI-built prototypes our radar shows how often that happens: 81% (367 of 454) of the DACH apps checked needed rework before launch.
Is a clickable prototype enough for a funding application?
For many programmes that fund concept work and validation, a clickable prototype is a sufficient, tangible solution. If a programme explicitly requires a working prototype or a pilot application, you need code. For North Rhine-Westphalia we have summarised the Go-to-Market voucher and AI funding programmes with their conditions; when in doubt, the funding guideline prevails.
Which format is better for an investor pitch?
It depends on what investors want to assess. For acceptance and brand impact, a clickable prototype is enough. For technical feasibility, especially with AI or deep-tech products, a code prototype is much more convincing because it shows the core risk is solved. By technical due diligence at the latest, investors ask about code, architecture and dependencies.
Related articles
- MVP basics
Validating Your Business Idea 2026: 6 Methods That Work
Validation in 6 stages from desk research to MVP, hard benchmarks, The Mom Test, a 14-day plan and what a smoke test needs legally in Germany, Austria and Switzerland.
- MVP basics
What Is an MVP? Definition, Examples & a 6-Step Guide
MVP explained: Eric Ries' definition, what “viable” really means, seven MVP types, examples from Dropbox to Zalando, a six-step guide and our own radar data on how safe AI-built MVPs in DACH are.
- Building an MVP
How Much Does an MVP Cost in 2026? Real Prices, Not Ranges
What an MVP costs in 2026, per type from the MVP cost index: hourly agencies vs. AI-native fixed prices, running costs after launch, hidden security and GDPR costs (with radar data from 454 apps) and a calculator for your case.
Clickable, code prototype or both? Let's clarify in 30 minutes.
Tell us briefly what you want to validate. We honestly say which format fits the question — and whether you need decivo for it or not.
We build both formats ourselves. Meaning: no sales pitch in favour of one variant.