esköre™

InsightsMobile App Development15 min readNovember 18, 2026

Clickable App Prototype Before Development: What to Build, Test and Sign Off

A clickable app prototype lets you tap through your app's screens and flows before development starts, so you can settle scope and sign-off with less risk. Here is what to build, test and agree first.

Mobile App Development at Eskore
Photo by Unsplash on Unsplash

A clickable app prototype before development is an interactive model of your app's screens and the paths between them. People can tap through the sign-up flow, open a record and reach the final action. Nothing behind the screens is real: there is no backend, database, payment processing or live data. Build one when the flow, the user roles or the scope are still open, because changes to a prototype cost design time rather than build time. Skip it or shorten it when real customers have already proven the flow.

What a clickable app prototype is and isn't

A clickable prototype sits between a sketch and a product. It shows how the app should look and behave: which buttons people press, the order of screens, the transitions and the messages they see. Most teams build it in a design tool such as Figma and link the screens together, so a tap opens the next one. If you want specialists to handle that work, our UI/UX design for clickable prototypes service covers research, flows and interfaces that are tested before development starts.

A static wireframe shows layout only: boxes, labels and placement. It has no taps and no flow, so every reviewer has to imagine what happens next. That is where most disagreements start.

An MVP, or minimum viable product, is different again. It is a working app that real customers use, with real accounts, real data and often real payments. A prototype answers whether the flow makes sense. An MVP answers whether people will use the product and pay for it. Mixing the two up is one of the costliest mistakes in this area, as we explain below.

Should you build a clickable app prototype before development?

Build one when:

  • The idea is unproven. You are still deciding which problem to solve, or you have not confirmed that the people you serve would use the app.
  • Your team disagrees about the flow. If the founder, the operations lead and the sales manager each describe a different order of steps, a prototype forces a decision.
  • The app has several user roles. A dispatcher, a field technician and a site manager see different screens. The handoffs between them are hard to judge without something to tap.
  • Someone must approve before money is committed. A board, a lender or a parent company may need to sign off a fixed price against something they can see.

You can skip it, or shorten it, when:

  • The app is a well-understood internal tool with one user type. Replacing a single spreadsheet with a form, a list and a report often has an obvious flow already.
  • Real customers have already completed the flow. If you have watched people finish the task in the current process, a prototype teaches you less.

Even if you skip the full prototype, write down your core screens and error states before you ask anyone for a price. A prototype of the three most important flows is a sensible minimum for most decisions.

Prototype or MVP: which to build first

Clickable prototype MVP (working product)
Question it answers Does the flow and layout make sense? Will real people use it and pay for it?
What you validate Navigation, copy, sign-off on flows Usage, retention, willingness to pay
Budget at risk Design and prototyping effort Build cost for the core features
Time to first test Shorter, measured in weeks Longer; depends on scope and integrations
Real or faked Screens, transitions, sample data; no backend Logins, data, payments, hosting, integrations
Cost of changes Design hours Development hours, and some changes are hard to undo

A prototype reduces the risk of building the wrong thing. An MVP reduces the risk that nobody wants the product at all. Many founders need both, in that order, though some need only one.

There is a middle step worth considering. When integrations or device behaviour matter, a short build on a real phone can test what a prototype cannot: how a camera scan behaves in poor light, what happens on weak signal, or how the keyboard covers a form. Treat it as a checkpoint between the prototype and the MVP.

What a useful clickable prototype must include

A prototype that shows only the happy path produces a scope that is wrong from the start. The happy path is what happens when everything works. Developers price the rest, and the rest is where most of the cost sits.

A prototype that can serve as a usable scope needs four things:

  • Every core flow, from sign-up or login to the final action. Take a hypothetical stock-count app for a warehouse team in Raleigh. The flow covers signing in, selecting a location, scanning items, reviewing discrepancies and submitting the count.
  • A navigation structure that shows where each screen sits, what the menu contains and how a user gets back.
  • Real copy instead of placeholder text. Button labels, error messages and confirmations reveal assumptions. "Submit" and "Finish count" describe different products.
  • Every state of every screen. This is the part most often missed.

The states people leave out most often are:

  • Empty. A new user has no jobs yet. What does the screen say, and what is the next action?
  • Loading. The data is on its way. Is there a spinner, a placeholder layout or a message?
  • Error. The barcode is not recognised, or the invoice failed to save. What does the user see, and can they recover?
  • Offline. A field technician loses signal halfway through a job. Does the app queue the update or lose it?
  • Permission denied. A user opens a screen their role does not allow. Is the option hidden, or is the restriction explained?
  • Success. The count is submitted. What confirms it, and where does the user go next?

Each of these becomes work in the build. If they are missing from the prototype, they are missing from the price, and they tend to come back as change requests.

It also helps to keep a short list of what the prototype does not cover. That stops everyone assuming a feature exists because a screen shows it.

What to fake and what to build

The prototype should fake what is easy to fake, and name what is hard, even if you do not build it yet.

Fake in the prototype:

  • Screen transitions and navigation
  • Sample data, such as a list of fictional customers or jobs
  • Mock responses, such as "order saved" after a tap
  • Dummy payment confirmations, such as a screen that says "Payment successful" without taking money

Keep for the build stage:

  • Real logins, including password reset and any single sign-on
  • Payments and subscriptions
  • Third-party integrations, such as accounting, e-commerce or mapping services
  • CRM or ERP data flows, meaning how a record moves between systems
  • Push notifications
  • Analytics events, the measurements that show whether people complete a flow

Name the hard parts for a simple reason. A smooth "Sync to accounting" button with nothing said about how it works makes the integration look like a small task. Label that screen with a note such as "Integration not built yet: invoices sync to accounting software," and describe the data that moves. Then a developer can price it, and you can decide whether it belongs in the first release.

If the prototype will be tested with real personal data, check your privacy obligations before you start. Canada has federal and provincial privacy laws, and several US states have their own. Get advice on your situation rather than relying on a summary.

Many prototypes are shared only as a link to a design file. That is useful for reviewing layout, but it hides the things that decide whether an app works on a phone. A design file does not show how a tap target feels under a thumb, whether the keyboard covers the field you are typing into, how a long list scrolls, or how a transition looks at normal speed.

Test on the device your users will hold. Ask a few people from the buyer group to use the prototype on their own phones, and watch what happens. Their hands and their habits will show you problems that a desktop review misses.

Then put device testing into the written scope. Name the phones, the operating system versions and who checks each one. A design link cannot answer those questions, and the answers belong in the contract. Eskore's commitments on any project are a written scope, a fixed price and a launch date, all agreed before work starts. Device coverage should be part of that scope, not a promise made in a sales call.

What a clickable app prototype costs and how long it takes

Published prices for prototypes vary so widely that we have not quoted any competitor figure in this article. Some guides price a basic clickable model. Others price a tested, high-fidelity prototype with user research and design phases. Many do not say which currency they use, or what the number includes. Before you compare quotes, ask each supplier to define what its figure covers.

Several factors move the number up or down:

  • Number of screens and flows. A three-flow app costs less to prototype than a fifteen-screen app with several roles.
  • Fidelity. A rough clickable model is quicker than a high-fidelity version with custom animation and full state coverage.
  • Testing. Whether user testing is included, and how many sessions it covers.
  • Team location and seniority. Rates differ by city and by experience. A senior designer costs more per hour and often needs fewer hours.
  • Reuse. A prototype that becomes the design system for the build is worth more than a one-off demo.

The simplest way to budget is hours multiplied by rate. Here is an illustrative example, not a market rate or an Eskore quote. A prototype that needs 80 hours at USD 150 an hour comes to USD 12,000. At an assumed exchange rate of 1.40 Canadian dollars to one US dollar, that is about CAD 16,800. The rate is there only to show the arithmetic. Check the live exchange rate on the day you budget, because it moves, and write the currency into the quote.

Timing depends mainly on how many flows and states you need. A three-flow app is a different job from a fifteen-screen app with several roles. Rather than trusting a general "a few weeks" figure, ask for a dated plan based on your counted screens, and make it part of the written scope.

Budgeting for the design stage in Canada

The prototype is part of the wider UI/UX budget, not a separate item. Research, flows, visual design and testing often run together, so ask suppliers to show each stage separately. Our UI/UX design service covers the design stage for Canadian and US businesses. For a wider view of what design work costs, read our UI/UX design cost guide for small business in Canada.

Before you sign, confirm three things with the supplier. Is the quote in CAD or USD? How is HST, or any other sales tax, applied? And what does the price include, such as testing sessions and revisions? We do not give tax advice here, so check the treatment with your accountant. Put the currency, the tax position and the inclusions in writing, alongside the scope.

If you are not sure whether a design stage suits your stage of growth, independent advice on whether to build or test first is the right conversation to have before you commit.

How to test a clickable prototype with five to eight real users

A small group of real target users usually reveals the main flaws. The team that designed the prototype knows what each button is meant to do, so it reads the flow correctly even when a stranger would not. Real users do not have that knowledge, and they show you where the flow breaks.

Five to eight participants is a common rule of thumb in usability testing, not a statistical guarantee. If the first few sessions show the same problem, you have learned something important. If they show different problems, keep testing before you decide.

Recruit people who match the buyer, not the team. A dispatcher who works the board every day is a better tester for a dispatch app than a developer who knows the stack. A clinic receptionist in Raleigh is the right tester for a patient intake app, whatever the designer thinks of it.

The method is simple. Give each person three to five realistic tasks, phrased as goals rather than step-by-step instructions. Ask them to think aloud. Then observe, and do not help. When someone gets stuck, resist the urge to explain. The moment of being stuck is the finding.

A short test script and what to measure

Here is a script for a session of about 30 minutes:

  1. Context. "Thanks for joining. We're testing an early version of an app. There are no wrong answers, and you can't break anything. Please think out loud as you go."
  2. First task. "Imagine you need to submit today's stock count for this warehouse. Show me how you'd do that." Watch without speaking.
  3. Follow-up probes. "What did you expect to happen when you pressed that?" "What is this screen for, in your own words?" "What would you do if the barcode didn't scan?"
  4. Remaining tasks. Give two or three more tasks in the same way, such as checking a discrepancy or finding last week's count.
  5. Closing questions. "What would stop you using this?" "What did you expect to see that wasn't here?" "What would you change first?"

Measure a few things in each session:

  • Task completion. Did the person finish without help?
  • Taps and wrong turns. How many steps did it take, compared with the path you expected?
  • Hesitation. Where did they pause, read a screen twice or look for a button?
  • Questions asked. Each question points to a label, state or step that is unclear.
  • Understanding of purpose. Could they explain what the app is for after the first task?

Record findings in a simple table with four columns: what happened, which screen, how serious it was, and what to do. Mark each item "fix before scope", "add as a later release" or "drop". Make these decisions before development starts. A change at this stage costs design time. The same change after development costs build time, and sometimes rework.

Turn the clickable prototype into a written scope

A prototype becomes something a development partner can price only when the open questions are answered in writing. The prototype shows what the app should look like. The scope says what gets built, how it is tested, when it launches and what it costs.

Before work starts, agree these items:

  • Flows and states. Sign-off on every core flow, including empty, loading, error, offline, permission denied and success states.
  • Integrations and data. Which systems the app connects to, which data moves, in which direction and how often.
  • User roles and permissions. Who can see and change what.
  • Analytics events. What you want to measure, such as completed counts or abandoned sign-ups.
  • Payments and subscriptions. Which provider, which plans and how refunds work.
  • App Store and Google Play requirements. Store listings, review steps and any policy issues for your category.
  • Acceptance criteria. The test that defines "done" for each feature.
  • Fixed price and launch date. Both agreed before work starts.

Eskore's position is that every project starts with a written scope, a fixed price and a launch date agreed before work begins. That matters most at the prototype stage, because this is where the scope either becomes precise or quietly grows. If a supplier cannot tell you what is in and out of the price, the prototype is not finished.

For the build itself, see our custom software development with a written scope and mobile app development services. You can also browse our recent app and software case studies.

Who owns the prototype files and the app code

Ownership is often left vague, and it should not be. Before you sign, check who holds each of these:

  • The design files, including the Figma project and its component library
  • The user flows and the written scope
  • The source code for the app
  • The App Store and Google Play developer accounts

Eskore's position is that you own the code and the accounts. Open the developer accounts in your company's name from the start, not in a contractor's name, so you can publish updates without depending on anyone. Ask for the design files to be transferred to you as well. Ask what happens to the files if the project ends, and make sure the contract says so. An agreement that is silent on those points leaves you exposed.

Read the clause, not the sales page. The contract should state, in plain terms, who owns the code, the files and the accounts, and how handover works.

Common mistakes to avoid

Prototype drift. The prototype and the build gradually diverge, because someone changes a screen in code without updating the design, or the reverse. Keep them aligned at sprint reviews. Each review should compare the build with the prototype and record every difference, whether it is an improvement or an error.

Calling a prototype an MVP. A prototype cannot take payments, store real customer data or show that people will keep using the app. If you present it to investors or customers as a working product, you create expectations the build cannot meet.

Leaving out error and empty states. These are the screens users see when something goes wrong or when they start with nothing. They are expensive to add late, because they touch every data flow.

Faking the hard integrations. A smooth prototype of an accounting integration makes that work look small. Name the integration, describe the data and mark it as not yet built, so the price reflects what it takes.

Handover delays. When design and development sit in different places or time zones, questions take days to answer, and the prototype gets interpreted in several ways. Keep the handoff tight, with a named owner for each decision. Eskore runs software, design, cloud and marketing as one team, so you have fewer suppliers to coordinate. You should still agree in writing who signs off each decision.

Next steps for your clickable app prototype before development

Here is the sequence we would follow:

  1. Decide whether to prototype. Use the criteria above. If the idea, the flow or the roles are still open, build one. If the flow is obvious and customers have already completed it, shorten the prototype or skip it.
  2. Define the must-have flows and states. Cover every core path, and name every error and empty state.
  3. Test with five to eight real users. Match the buyer, give realistic tasks, and watch without helping.
  4. Agree a written scope, fixed price and launch date. Settle integrations, roles, analytics, payments, store requirements and acceptance criteria before work starts.
  5. Confirm ownership. Check that you own the files, the code and the developer accounts, and that the contract says what happens if the project ends.

Eskore works across software, design and cloud from offices in Toronto, Thornhill, London and New York, and serves clients across Canada and the United States.

If you are weighing a clickable app prototype before development, or you have a flow you are not sure about, book a free 30-minute scoping call. We will look at what you have, tell you whether a prototype is the right next step, and outline what a written scope would need to include.

Questions

Need help with this?

Talk to our mobile app development team.