MVP & Working Prototype
If you want to build an MVP, you're usually not looking for a presentation, you're looking for something that actually runs. Slides can explain an idea, but only a working version shows whether it holds up, whether a click actually does what it should, and whether the core function convinces in practice. We build real, operable software for the one core function that matters, no click-dummy, no animation, but a proof of feasibility you can put your hands on. This is the larger, scoped-out version of our free two-day demo: more scope, more depth, with a fixed price after a short discovery call.
Who this prototype is for
- You need to justify a larger investment internally, and a slide deck no longer convinces management or the board as a basis for a decision.
- Several departments or shareholders talk about the same idea but picture different things, because there's still no shared, tangible version of it.
- You're standing on a stage, in front of a client, or at a conference, and want to demonstrate something that actually responds instead of explaining screenshots.
- You want to know whether an idea works before committing the budget for full development.
- You're heading into a conversation with investors or a funding body like aws or FFG, and a pitch deck alone no longer convinces at the evaluation stage.
- You want to sell a potential client a new digital offering, but without a tangible example it stays abstract and hard to price.
What you receive
A working application
Not a click-dummy or a wireframe, but software you or your audience can actually operate, on a laptop, tablet, or via a shared link. You click, type or scroll for real, and the application responds for real.
The one core function, done properly
Instead of ten half-finished features, we build exactly the one function that matters for your decision or your presentation, fully and reliably. Everything around it that isn't needed for the core message, we deliberately leave out.
Demoable without a developer standing by
You can operate and explain the prototype yourself, without one of us standing next to you explaining what's currently just simulated. That holds even when you show it to investors, the board, or from a stage.
Realistic data instead of placeholders
The prototype runs with data that resembles your day-to-day, not lorem-ipsum text or made-up sample names. That makes it credible in front of a real audience, without you having to expose real customer data.
A written assessment for what comes next
We document what actually runs, what's simplified or hardcoded, and what a production-ready version would still need, such as security, load handling or edge cases. That way you know how big the next step really is before you budget for it.
The source code is yours
If the idea proves out, the code can serve as the starting point for full custom software development, with us or elsewhere; there's no obligation to continue. You get the repository and all necessary access as soon as the build is paid for.
How it runs
Initial call
We clarify exactly what needs to be shown, to whom, and by when. From that follows how big the prototype actually needs to be and how tight the timeline is.
Scope & fixed price
We define the one core function and fix the scope, price and deadline before we start building. That way both sides know exactly what will be delivered, and what won't.
Build
We usually develop the prototype within a few working days and keep you updated on progress. If questions about the core function come up, we reach out directly instead of guessing.
Handover
You receive the prototype, the code and the written assessment in time for your deadline, with enough room for a dry run. We walk you through it live once, so you can demo it yourself afterward without us.
Build cost
The prototype is a one-time investment at a fixed price, not billed by the hour. The price depends on the scope of the one core function and how tight the deadline is that it needs to meet. A prototype usually doesn't need ongoing operation; if you want to keep it running afterward, we discuss hosting and maintenance separately, as with a tailored solution. For Austrian businesses, part of the build is often eligible for funding programs such as KMU.DIGITAL.
We agree on concrete prices in the initial consultation. All amounts excl. VAT.
What this costs to keep running is covered under operation & ongoing care, and where your data physically sits under hosting in Austria & the EU.
See all servicesFrequently asked questions about MVP & prototype
No. The free demo is a small, no-obligation two-day test with no contract. This module is the larger, paid version of it: more scope, more depth in the one core function, and a fixed price set after a short initial call.
No, and that isn't the goal. A prototype is built to demonstrate and test an idea, not to withstand real user load, security requirements or edge cases in ongoing operation. If it proves out, the next step is full development, for example as custom software.
The code is yours once the build is paid for. You can take it and continue with any other developer. Honestly, though, a prototype built for speed isn't always documented cleanly enough for someone else to pick up without an onboarding period, and we'll tell you that plainly.
Usually within a few working days, up to two or three weeks depending on scope. We fix the exact date in the initial call, oriented around your target date, such as a conference or a board meeting.
Then the prototype has done its job. It's far cheaper to find that out from a working core function than after a full development.
The price depends on the scope of the one core function and how tight the deadline is that the prototype needs to meet, not on hourly rates. We set it as a fixed price in the no-obligation initial call, once it's clear exactly what needs to be shown. As an Austrian business, you can check whether part of it can be covered by a funding program such as KMU.DIGITAL, we look into that together if relevant. We deliberately give a concrete figure only after that call, because without a defined scope it would be pure speculation.
Yes, that's a common path afterward. The prototype code can serve as the starting point for custom software development, though usually a good part of it gets reworked or rebuilt from scratch, because a prototype built for speed had different priorities than production-ready software. How much of it is reusable, we estimate in the written assessment you receive with the prototype.
No. For a prototype it's enough if you know which one core function needs to be shown, and in front of whom or what. The rest, scope, flow and technical shape, we work out together in the initial call.
