StackLift
All terms

Glossary

Prototype

An early, interactive model of a product used to test design and flow before the real build.

A prototype is an early, interactive model of a product, from paper sketches to clickable screens, used to test how it looks and works before it is built. It lets users and stakeholders react to the design while changes are still cheap.

Prototypes vary in fidelity. Low-fidelity wireframes settle layout and content, and high-fidelity clickable versions support usability testing.

A prototype is not working software. It usually lacks real data, security and error handling, so it should inform the build instead of becoming the product.

Start in 60 seconds

Put this to work on your project.

Get an AI-assisted, architect-reviewed scope, cost range, and timeline. Free, no login.

The complete guide

Prototype: the complete guide

Updated November 18, 2026 ยท Published by , Founder, StackLift AI. Written with AI assistance; how we make content.

Short answer

A prototype is an early, interactive model of a product, from paper sketches to clickable screens, used to test how it looks and works before it is built. It lets users and stakeholders react while changes are still cheap. A prototype is not working software, and it should inform the build instead of becoming the product.

What is a prototype in software?

A prototype is a stand-in for the real product, built to learn something before you commit to building it. It shows how screens connect, what a user sees and what happens when they tap or click. People can try it, and you watch where they hesitate.

The point is to be wrong cheaply. Moving a button in a design file takes minutes. Moving it after the feature is built, tested and released takes much longer. A prototype brings design problems to light while changing them is easy.

A prototype can be rough or polished, but it is a model, not the thing itself. Behind the screens there is usually no real database, no real security and no real logic.

Why build a prototype?

  • Test usability: find where people get lost before developers build the wrong thing.
  • Align stakeholders: a clickable model ends debates that a written description cannot.
  • Make requirements concrete: people spot missing steps once they can see the flow.
  • Reduce rework: design changes cost less before development starts.
  • Support decisions: show investors, sponsors or customers something tangible.
  • Improve estimates: a clear design reduces uncertainty in the software estimate.

A prototype also gives a written product requirements document a visual companion. Together they leave less room for different people to imagine different products.

What are the types of prototypes?

Prototypes vary in fidelity, which means how closely they resemble the final product. Choose the lowest fidelity that can answer your question.

Prototype fidelity levels
TypeWhat it isBest forCost to change
Paper sketchHand-drawn screensEarly ideas and layoutVery low
Low-fidelity wireframeSimple grayscale screens linked togetherFlow and content structureLow
High-fidelity designFull visual design with real stylesLook and feel, stakeholder approvalMedium
Clickable prototypeDesigns linked so users can tap through tasksUsability testingMedium
Coded prototypeReal front-end code with fake or limited dataComplex interactions, animations, AI responsesHigher
Wizard of OzLooks automated, but a person does the work behind the scenesTesting demand for an AI or automated featureVaries

Low fidelity is often better early. People give more honest feedback on a rough sketch because it looks easy to change, while a polished design invites comments about colors instead of the flow.

How do you build and test a prototype?

  1. Decide the question: which task, flow or screen do you need feedback on?
  2. Pick the user and the task they will attempt, such as booking an appointment or approving an invoice.
  3. Sketch the flow on paper or in a whiteboard tool, then agree the screens needed.
  4. Build the prototype at the fidelity that answers the question, using a design tool such as Figma.
  5. Link the screens so the main path can be clicked through, and prepare realistic text and sample data.
  6. Test with a handful of real users from your target group, asking them to complete tasks while thinking aloud.
  7. Note where people hesitate, misread or fail, and rank the issues by how often and how badly they hurt.
  8. Revise and retest, then hand the confirmed design to the team as the basis for user stories.

A small number of test users usually surfaces the biggest problems. Run short rounds, fix, and test again instead of one large study.

What are examples of prototypes?

  • A clickable booking flow in a design tool, tested with customers before any back end exists.
  • A coded dashboard with sample data, used to agree which charts leaders actually need.
  • A chat interface for an AI assistant with scripted answers, used to test tone and handoff to a person.
  • A paper sketch of a warehouse tablet app, tried by staff with gloves and a bright floor in mind.
  • A clickable client portal showing project status, documents and invoices, reviewed by a client before development.
  • An onboarding flow for a SaaS product with three variants, compared with test users.

These are common patterns, not results from named organizations. Each one exists to answer a design question, and none of them needs production code to do so.

How do you prototype an AI feature?

AI features add a wrinkle: the experience depends on what the model says, and that can vary. A pure design prototype with scripted answers can test layout and tone, but it hides the main risk, which is answer quality.

  • Use a design prototype with scripted answers to test the interface, flow and handoff.
  • Use a coded prototype with a real model call on a handful of cases to see how real answers look.
  • Show failures too: what the interface does when the model is wrong, slow or unsure.
  • Keep a person in the loop in the test, and observe what users do with imperfect answers.
  • Move to a proof of concept if the open question is whether the model can do the task at all.

Prototypes built quickly with AI coding tools are useful for exactly this. They are not production software, though, and the vibe-coded app rescue page covers what to do when one is about to go live.

Common prototype mistakes

  • Shipping the prototype. It lacks security, data handling, tests and error cases, and it will need a rebuild or a rescue.
  • Too much polish too soon, which wastes time and invites feedback on colors.
  • Testing only with colleagues who already know the product.
  • No clear question, so the session produces opinions instead of findings.
  • Leading users through the task instead of watching them try.
  • Ignoring non-happy paths such as errors, empty states and slow loading.
  • Stopping at screens and skipping the rules behind them, such as who can see what.
  • Treating approval of the prototype as approval of the scope. Record the agreed scope separately.

How do you know whether a prototype worked?

Judge it by what you learned, not by how it looked. A prototype worked if it answered the question you set, and if the next step is clearer than before.

  • Task completion: could users finish the key tasks without help?
  • Time and effort: how long did tasks take, and where did people stall?
  • Errors and confusion: which steps were misread or skipped?
  • Language: did users use your terms, or their own?
  • Confidence: did testers say they would use it, and why or why not?
  • Agreement: did stakeholders sign off on the flow?

How does a prototype hand off to development?

A prototype only pays off if what it taught you reaches the people who build. The handoff turns screens and findings into something engineers and testers can work from.

  1. Freeze the agreed design and note what changed from earlier rounds and why.
  2. Write the behavior behind each screen: rules, validations, roles and error states.
  3. Turn flows into user stories with acceptance criteria.
  4. Attach the prototype to the product requirements document as a reference, not a substitute for it.
  5. List what the prototype faked, such as data, integrations and permissions, so no one assumes it exists.
  6. Agree the scope for the first release and treat later additions as change requests.

A design system, meaning a shared set of components, colors and rules, speeds the handoff and keeps the built product consistent with what users tested.

What tools are used to build prototypes?

Common prototyping tools by purpose
PurposeTypical toolsNote
SketchingPaper, whiteboards, tablet drawing appsFastest way to explore ideas
Wireframes and clickable designsFigma, Sketch, Adobe XD alternativesShared online, easy to comment on
Coded front-endReact, Next.js, HTML and CSSBest for complex interaction
AI-assisted buildersAI code and app generatorsFast to produce; plan to rebuild or rescue before launch
User testingModerated video sessions, recorded task testsNeeds a clear task script

Tools change often, so choose by the question you need answered and who must review the result. A tool the whole team can open and comment on is worth more than a powerful one only a specialist can use.

What does a prototype mean for cost and timeline?

Cost and time depend on the fidelity, the number of flows and the amount of testing. A paper or wireframe prototype is fast. A coded prototype with real interactions and several rounds of testing takes more time.

  • Fidelity: sketches, wireframes, high-fidelity designs or code.
  • Number of screens and user journeys covered.
  • Interaction complexity, including AI responses and data.
  • Rounds of user testing and the effort to recruit testers.
  • Whether a design system or brand style already exists.

Set that against the cost of building the wrong thing. For full-project context, see the web application cost page and the guide to building a SaaS MVP, and run the free estimate.

How does StackLift approach prototypes?

Every engagement starts with structured discovery and an architect-reviewed scope. The AI Scope Sprint is a 3-day scoping plan that produces detailed scope, user stories, tech stack, and a cost and timeline range, so design questions are settled before engineering begins.

For teams that already have an AI-built prototype, the vibe-coded app rescue service audits and hardens it. For a first release, the MVP Build Sprint turns the agreed design into production software.

Questions people ask

What is the difference between a prototype and a wireframe?

A wireframe is a simple layout of a screen, usually static. A prototype links screens or behavior so that users can try a task. Many prototypes start as wireframes.

What is the difference between a prototype and an MVP?

A prototype tests the design and is usually not working software. An MVP is a real product with limited features that real users rely on. A prototype informs the build, and an MVP is the first build.

Can a prototype be turned into the real product?

Usually not safely. Prototypes lack security, tests, data handling and error cases. Treat it as a design reference and rebuild, or audit and harden it before going live.

How many users should test a prototype?

A handful from your target group in each round usually shows the main problems. Run short rounds with changes between them instead of one large study.

Which tools are used to build prototypes?

Design tools such as Figma are common for clickable prototypes, and front-end code or AI coding tools are used for coded ones. Choose by the fidelity your question needs.

Do I need a prototype before development?

It helps when the user experience is new, complex or unclear. For a familiar pattern with a clear design system, you may go straight to building, with design review along the way.

Is a prototype the same as a mockup?

No. A mockup is a static picture of how a screen will look. A prototype adds interaction so users can click through a flow and you can watch what they do.

How realistic should prototype data be?

Use realistic text, names, amounts and edge cases, not placeholder text. Test users react to what they see, so a table full of filler hides problems such as long names, empty states and large numbers. Real-looking data also helps stakeholders judge whether the design fits their daily work.