Key takeaways

  • A clickable prototype shows whether people understand the flow and whether the product communicates its value. It does not prove that the system behind the screens can deliver that experience.
  • A good prototype is not enough on its own to start development. Real data, integrations, business rules, permissions and failure handling each need their own check.
  • Developers should review the proposed flows before the client sees the prototype, so the client is not asked to solve problems the team could have found.
  • A prototype can also surface missing requirements, such as an extra user role, while changes to the design are still small.
  • Add a slide called "What This Prototype Does Not Prove" and use a table with three columns: what we have validated, what remains unproven, and what to test next.

As Product Strategist and Creative Lead at Ostride Labs, I see a prototype as a way to check whether a design actually works. Does the user understand what to do? Is the user flow clear? Does the product communicate its value? Can the client see what we are trying to build and why it matters?

A clickable prototype helps us answer these questions before we start development. We can put a design in front of people, see how they interact with it, and make changes while those changes are still relatively easy to implement.

But there is an important distinction between validating the experience and validating the product itself. A prototype can show how a product is supposed to work without proving that the underlying system can deliver that experience. Problems arise when stakeholders approve the screens, and everyone treats that approval as sign-off on the product.

For me, getting to a prototype that is ready to show the client involves quite a bit of work that happens before the presentation.

Design and development need to align before the prototype reaches the client

I believe design and development should work together well before we present a clickable prototype. The development team needs to review the proposed flows, understand how the intended functionality will work, and confirm the technical feasibility of the solution. That includes identifying the integrations required and understanding any constraints that could affect the experience.

Otherwise, we risk presenting the client with something that looks convincing but is based on assumptions nobody has checked. A designer might propose a flow that makes perfect sense visually, but the required data may not be available through an API, or an integration might not support the expected behaviour.

These are things we should work through before asking the client to approve the design.

Our approach is to resolve as many of these issues as possible before the prototype reaches the client. I don't want to present a solution with a list of known problems that we expect the client to help us figure out. If we already know that a flow will not work because of a technical limitation or a design issue, it is our job to find a better solution.

The client should be able to focus on whether the product makes sense for their business, whether it communicates the right value, and whether the proposed experience meets their needs. They should not have to do the team's problem-solving for us.

This does not mean that everything is set in stone once the prototype is presented. If the client's vision changes or a new requirement emerges, we adapt. But that is different from presenting a design with problems we prefer to have identified and addressed beforehand.

A design can be technically feasible and still not work for the user

Even when developers have confirmed that a design can be implemented, we still need to understand whether the experience makes sense to the people who will use it.

A design can look perfectly clear in a Figma prototype and still fail to communicate what the user needs to do. Prototype testing helps us understand whether the flow makes sense in practice, whether the navigation is intuitive, and whether the product communicates its value clearly.

These are exactly the kinds of issues we want to catch before development starts. At this stage, we can still make meaningful changes to the design without having to rework functionality that has already been built.

Sometimes the solution is a small adjustment to the copy. Sometimes we need to rethink the navigation or restructure the entire user flow. The important thing is that we can identify what is not working and address it before investing in implementation.

A prototype is also an opportunity to discover requirements that were not obvious when the team was discussing the product on paper.

We have had cases where a client reviewed a completed prototype and realised that the product needed to support an additional use case. That also meant expanding the role model to accommodate another type of user.

Because we identified this at the prototype stage, we could make relatively minor changes to the design and account for the additional role before development moved forward.

Had we discovered the same requirement after the architecture had been designed around the original role model and the first version had been built, the change could have been much more expensive. Extending a role model can affect permissions, business logic, and other parts of the system, not just the screens a user sees. Changing those assumptions after implementation could have increased both the delivery time and the cost of the project.

The prototype gave us a chance to identify a missing requirement while we still had the flexibility to accommodate it without significant rework.

What a clickable prototype cannot prove

Even when the design has been validated with users and reviewed by developers, a prototype does not prove that the finished product will behave as expected.

Some issues only become apparent when we start working with real data and real input. For example, a user's full name might be much longer than the one used in the prototype, causing it to overflow or get truncated in a way that makes the interface look broken. A text field might work perfectly with a short input but fail to expand when someone enters a longer response, making the text hidden, difficult to read while they are typing, or difficult to review when they finish.

These details might seem minor, but they affect how polished and usable the product feels. A prototype with carefully prepared content will not necessarily reveal them, which is why we need to think about real data and edge cases before the implementation is considered complete.

Other issues only become apparent when we look at how the product will work behind the interface.

For example, imagine we are designing a calling feature and propose letting users join a call through a link. If the third-party API only supports initiating a direct call and does not provide a way to generate or join calls through links, that interaction simply cannot be implemented as designed. If we had built the prototype without checking this first, we could have presented the client with a flow that the underlying integration does not support.

This is exactly why I want developers involved before we present the prototype. We should not be showing the client a solution that depends on functionality the chosen integration cannot provide.

The same applies to business rules, permissions, and failure scenarios. A prototype can illustrate how the interface should respond when a request fails or a user attempts an action they are not authorised to perform, but it cannot prove that the underlying system will handle these situations correctly.

Moving from a prototype to development should therefore involve targeted technical checks. Depending on the project, this might mean testing a representative sample of real data, checking how the interface handles different input lengths and edge cases, validating a critical integration, or reviewing permissions and error-handling requirements with the engineering team.

The goal is not to anticipate every possible issue before development begins. It is to identify the assumptions most likely to affect the product and test them before the team builds too much around them.

Make it clear what the prototype actually proves

I think it is useful to be explicit about what has and has not been validated when presenting a prototype. Visual approval should not automatically be treated as approval of the entire product.

One simple habit I would recommend is adding a slide to the prototype presentation called What This Prototype Does Not Prove.

For example, we might have confirmed that users understand the onboarding flow, while still needing to test it with real data. Developers might have confirmed that an integration is feasible, while the integration itself remains unverified.

These are different levels of validation, and the client should be able to tell them apart.

A simple table can help make this distinction concrete:

This gives everyone a clearer understanding of what has been established and what still needs attention. It also helps the team distinguish between questions that require a business decision from the client and technical problems that the team should resolve itself.

A prototype is a step towards a product, not a promise that it is ready

For me, the value of a prototype lies in the decisions it helps us make before development becomes expensive to change.

It should help us validate the user experience, uncover missing requirements, and give the client a realistic picture of the product we intend to build. To achieve that, design and development need to work together from the beginning, and the team needs to address known issues before presenting the solution.

At the same time, we need to be honest about what a prototype cannot establish. A convincing interaction does not prove that real data, integrations, permissions, and failure handling will all work correctly. Those require their own validation.

A good prototype gives us confidence in the direction we are taking. The next step is to make sure the system can actually deliver the experience we have agreed on. A prototype proves the story. The checks that follow prove the system.

Frequently Asked Questions

A proof of concept checks whether an idea is technically possible, often with throwaway code and no real interface. A prototype shows how the product will look and behave for its users. In short, a proof of concept answers “can we build it?”, and a prototype answers “will people understand and use it?

A clickable prototype is a set of linked screens, usually built in a design tool such as Figma, that simulates the product without real code behind it. A working prototype runs on real code, so it can connect to data and integrations, although usually only for a few core features.

Prototypes are usually grouped by fidelity. Low-fidelity prototypes, such as paper sketches and wireframes, test structure and ideas cheaply. High-fidelity prototypes look close to the finished product, and clickable ones let people move between screens. Working prototypes add real code for selected features.

Read more

Compliance & RegTech

How to Implement eKYC Without Killing User Experience: Technical Guide

Adam Miller
10 min12 November 2025
Read the article
technical-guide

Fractional CTO vs. Full-Time Hire: The SME’s Decision Framework

1 min17 March 2026
Read the article

Need a technical read on your next product decision?

Tell us what is changing in the product, delivery plan or live system. We will help identify the right next conversation.