The value of a prototype is in the insight it imparts, not the code.

The value of a prototype is in the insight it imparts, not the code being written. Prototyping lets us fail fast and cheap, or get the data to make a concrete decision on direction. It helps answer the question, “What happens if we try this?”. Most significantly, prototyping provides us with the guardrails to safely and productively fail. Failure is an integral part of the process of learning.

Prototyping is the right tool if you have an idea to validate, a clear path to get feedback on, or a proposal requiring further data. It provides crucial insights to move forward. By creating a rough version of a feature or system you’ve been considering, you gain the flexibility to either discard the idea or fully commit to it. It’s a skill that assists product and engineering teams in making pivotal business decisions.

Whether it’s a website, mobile app, or landing page, no matter what product you’re working on, it’s always essential to verify your design decisions before shipping them to the end-users. Some development teams delay the validation stage until they have a solution that is almost complete. But that’s an extremely risky strategy. As we all know, the later we come across the problem, the more costly it becomes to fix it. Luckily, no matter what point you are in the design process, it is still possible to build and test a concrete image of your concept—a prototype.

The idea

“[Prototypes] don’t focus on the solution, but on understanding the problem. They ask the question, “What happens when we try this?” Maybe we learn it’s the right idea, but more likely, we learn something about the problem we didn’t know before.” - Jared Spool

Consider an architect tasked with designing a grand building. Before laying the first stone, the architect crafts a miniature scale model, allowing them to visualize the end result, understand the project’s complexities, and present their ideas convincingly to others. However, this model is far from being the final product; it’s a means to an end. This principle applies just as aptly in the world of software development.

A software prototype—whether it’s a low-fidelity wireframe, a high-fidelity interactive model, or a simplified mock-up of a more complex system—is much like the architect’s scale model. It’s a visual, often interactive, model of the software that provides developers, stakeholders, and users with an early glimpse into the software’s workings, long before the final product is ready.

The prototype isn’t about the code per se; the code is merely a tool used to create it. Instead, it is about gathering valuable insights, comprehending user needs, identifying functional requirements, validating technical feasibility, and discovering potential stumbling blocks that might arise during full-scale development. The prototype’s strength lies in its capacity to provide these insights without necessitating a significant investment of time or resources.

Prototyping may also be used to determine large opportunities before investing a team’s full resources into them. Creating a rough version of the feature or framework that you’ve been tossing around for a while gives you the ability to choose not to do it, or absolutely go forward with it. Prototyping is also a skill that helps product and engineering teams make essential business decisions.

Depending on the scenarios, prototyping can be ideal for a lot of things like:

• Exploring new ideas
• Concept validation
• Identifying future issues early on
• Trying out ideas with low risk and low investment
• Aligning the team with a common understanding of a feature
• Showing clearly what needs to be built
• Explaining clearly what it would be like to use

The Prototype as a Learning Tool

Consider the prototype as a tool for discovery and education. It is a platform for dialogue among all the stakeholders, from software engineers to clients to end-users. Every interaction with the prototype is an opportunity to uncover latent requirements, identify potential pitfalls, or spark innovative ideas. The prototype, thus, becomes a laboratory for experimenting, learning, and improving.

This learning is not confined to functional and operational insights. A prototype can also teach us about feasibility and viability, about project scope, about the actual utility of the proposed solution, and about the ways users will interact with the product. It is this education, this learning, that outweighs the value of the prototype’s code.

Code: A Means to an End

It’s crucial to remember that in a prototype, the code serves merely as a medium—a way to facilitate understanding. It’s a means to an end, not the end itself. The code of a prototype is disposable and mutable. In contrast, the lessons learned from a prototype, the insights gained from user interaction and feedback, are far more durable and impactful. These lessons will shape the final product, drive decisions, and ultimately determine the success or failure of the project.

Types of prototypes

To thoroughly appreciate the power of prototypes, we must understand their diverse forms:

• Feasibility Prototypes: These are written to test the technical viability of ideas. They help identify limitations.
• Low-fidelity User Prototypes: Interactive wireframes created by designers help test workflows and identify usability issues early in the design process.
• High-fidelity User Prototypes: These are realistic simulations useful for communicating a proposed product to stakeholders and finding potential issues through defensive user testing.
• Live-data Prototypes: Developers create limited implementations that access real data and handle live traffic to prove that the concept works. These prototypes lack productization aspects like test automation, localization, etc.

Image credit: Reforge

Each prototype, regardless of its type, serves to provide invaluable insights into various aspects of product development, from technical feasibility to user experience and product-market fit.

How to approach prototyping

When designing a prototype, they are multiple principles that could prove very helpful, and here are a few:

Hypothesize, and describe success and failure

Your hypothesis is the idea of what the prototype is meant to prove or refute. Meaning it is the agreed standard of what the prototype should do. Defining what success looks like when coming up with this hypothesis, especially when assessing subjective design directions, is important.

It’s also equally important to determine what failure looks like. Keep in mind that failure is not anything to prevent here; it’s just one of the potential outcomes to prepare for. Failure would almost always lead to issue reformation and a new prototype. Making it the relation between the design process’s phases of conception and prototyping. Failure allows an overhaul of the prototype and brings you closer to the ideal model you have in mind.

Write code you can throw away for your prototype

Prototyping is an opportunity to test your concept without all the complexity that comes with the engineering of the production process. If you’re planning to throw away the code at the end, then it’s all fair game to use shortcuts like imperfect code, missing the tests, etc.

Working in a separate branch or repo or perhaps isolating the prototype to your own page can help mitigate integration issues and improve the readability of code when writing production code is needed.

Evaluate the data and make a decision

The takeaway of prototyping is not the code itself or the output, but the learning that comes out of it. Take the time to review and record the work, and determine what you are going to do with the new material.

Some questions that could help you assess the prototype are:

• What has gone well and what hasn’t?
• Were any surprises there?
• Have the standards we set for success been fulfilled?
• Were any of the conclusions wrong?

Furthermore, documenting the lessons learned is not just a helpful way of recapturing the work. Over time, it can become a valuable historical resource down the road when contemplating similar concepts from another team. The willingness to say “we have tried that; here’s what we’ve found” provides useful signals for others to work with.

“The golden rule of prototyping — and developing any new idea — is to fail early and fail inexpensively. Prototyping enables misunderstandings to be identified and addressed as early in the design process as possible. The earlier in the process issues are addressed, the better, saving you time and money.” - Christopher Murphy

If your experiment failed, the next move might be to formulate a new theory and attempt another solution. If the prototype has been successful and has shown the feasibility you’ve been searching for, you can capture what you’ve learned in a design doc that can serve as a foundation for the project moving forward.

Conclusion

The aim of prototyping is not the prototype itself or its immediate output but the knowledge that comes from it. The lessons learned from each iteration of a prototype can be documented and can serve as a valuable historical resource for similar projects in the future.

In conclusion, prototyping is a robust tool for product development. By testing concepts and evaluating design decisions before final implementation, prototyping saves time, reduces cost, and enhances the quality of the end product. Whether you’re a seasoned engineer or a budding designer, mastering the art of prototyping can greatly elevate your product design process.