How to Benefit the Most from Prototypes in Software Design
Getting the most out of prototypes is to achieve simulations as close as possible to the final product. In short, it’s the best way to try out a design before it’s built. But design prototypes should go beyond sketches, diagrams, and maps. In software solutions, for example, prototyping is a step above wireframing. Think of it as a model or sample of the real thing but with purpose and functionality. The prototype can serve as a guide in architecture by scale or be interactive for user testing in software. In addition, a prototype can provide software engineers with a better understanding of the project’s costs, targets, and timelines. And for those of you who are new to prototyping, the concept has been around a long time.
In UX design, however, it is created to simulate the user experience and how they interact with the interface. Ultimately, prototyping helps to generate the standard by which to create the final product. So, getting the most out of your prototype should be a priority.
Prototypes can be found where you least expect. For example, there are prototypes in music and literature. According to Oxford dictionary, prototype is derived from the late 16th century via French or late Latin from Greek word prōtotupos. “Prōto” meaning first and “tupos” meaning pattern, mold, or impression. This early use of the word denoted “the original of which something else is a copy or derivative.”
Today, however, most people think of engineering when they hear the word prototype. It is defined by Oxford as “A first or preliminary version of a device or vehicle from which other forms are developed.” This is closer to the software technology definition. So, prototype is a powerful word. And it represents an even more powerful tool. A tool used by many cultures and by innovators in literature, art, music, science, engineering, and business. Its importance stems from what it simulates. It represents what the designer has in mind before the final concept or product is created.
The history of prototypes.
Okay, so the word itself has been around for centuries. But is there any actual evidence of ancient prototyping in recorded history? According to one article, The Long History of Prototyping, “prototyping has always existed and probably, for most of human history.” So, although some like to think that creating a prototype is a modern concept, it’s not. The difference, however, may be modern considerations like the user experience that now goes into creating them. Because users tend to dictate what they want and what they expect.
As far as recorded history, there are some pretty amazing examples of prototypes from ancient times to today. For example, a walking wooden horse invented by Lu Ban of China in 480 BC to transport supplies during wartime. Could this have been the predecessor to the modern automobile? Then, in 1495 Leonardo da Vinci moved past the sketching and built a working robot prototype. Unfortunately, it was never found but at least two people, including a NASA roboticist, used da Vinci’s notes to recreate a working model. And what about the video game prototype, “Brown Box” by Ralph Baer in 1967? His team knew it had to be fun and once they played ping pong, they were sold! It was eventually licensed to Magnavox who released the Magnavox Odyssey in 1972. Then fast forward to 2007, when Apple launched the first iPhone, which came after a long list of prototypes.
Prototypes for software design solutions.
In software design, prototyping is a crucial phase. But how can you be sure you are getting the most out of your prototype? Ideally, the prototype should show what the designer had in mind when they designed the software, app, or website. It does not, however, always contain the exact logic that is used in the actual software. And as Adobe confirms, it is not about static “sketches, wireframes, and mockups.” A design prototype must include interactive concepts. This is particularly important to UX design to communicate with users and inform designers.
Understanding the user experience and how they react and interact with software can be the ultimate game changer. To be successful, the prototype should be interactive, usable, and testable. If done correctly, it will be created based on the wireframes. But the prototype goes beyond wireframing and takes the design to the next level. Of course, this comes after extensive UX research including idea gathering, relevant data and information, evaluation, and demands. Ultimately, the idea is to design an interactive prototype that simulates how the real system would work, functionality of a website, or an app. And, if there are doubts about screens or elements in the wireframes, this is the chance to fix them.
Importance of testing.
In any event, the prototype will need to be working, interactive, and allow for user testing. The purpose behind the prototype is to evaluate an idea or design. And, ideally your prototype will provide multiple concepts presented for evaluation. By testing these concepts in parallel, designers will be better informed on necessary tweaks. In essence, finding out how users understand and interact with the prototype will give you a roadmap to improve the design. Testing is the best weapon you will have to predict a product’s success. You don’t want to cut corners here. You’ll want to provide a testable prototype that reveals pesky problems and highlight amazing victories. As such, an accurate simulation of the design is essential.
What version of prototype is best?
So, what version of prototype should you consider when investing the time and effort? When deciding between low or high fidelity, it depends on the level of detail and functionality that you’re looking for. Do you want something that is simple, low tech, and that allows for inexpensive fixes? Or, do you want to dive into a full-blown and highly functional prototype that is ready to go and impress! Deciding on the type of design prototype that works best is primarily based on the product team’s goals. What are they hoping to learn with this prototype? But the decision could also weigh on costs and resources. Time issues may also dictate which prototype is possible under certain conditions. Here are some important things to consider:
Low-fidelity vs high-fidelity prototypes.
A low-fidelity prototype involves simpler, low-tech concepts with less attention to visual attributes. It only goes so far as to include key element shapes and hierarchy. It is a scaled-down representation with limited functionality and is created to explore how users will interact with design concepts. This prototype is a customer-driven approach and opens the door to honest feedback. The idea is to gain empathy with users and learn from their experience. This allows for earlier and cheaper fixes as feedback dictates. In addition, it allows for more collaboration with others due to its low-tech nature. And this prototype is great for use with A/B testing. The low-fidelity prototype provides more options and opportunities to “get it right” by focusing on interactivity rather than the visual aspects. Gaining this type of insight leads to better UX experiences and better solutions and products.
On the other hand, is the high-fidelity prototype. This prototype is a full functioning one like maybe a website. It’s emphasis is on interactions and user interface but represents the design team’s understanding of what works best. In addition, it is more time consuming than its low-fidelity counterpart. The high-fidelity prototype should resemble and be as similar as possible to the final product. It’s created for final testing by actual users, stockholders, etc.
But what makes this prototype different is that it showcases visual details. Users will be wowed by what they see with the graphics and content that resembles or will be included in the final product. The beauty (pun intended) of this prototype is its ability to test UI design elements and interactivity. But you won’t get off cheap when you consider the additional time it takes to correct any potential issues. However, this should be expected at this close-to-final prototype stage. On the up side, when creating a hi-fidelity prototype, a considerable amount of front-end development work will have been completed.
One prototype and done? Think again.
Design thinking is a non-linear process. Designing software solutions moves from idea to prototype to testing and back again. And there are other phases in between. This back-and-forth holds true in the prototype phase as well. In fact, the idea of a prototype is to get user feedback that is used to improve it. So, it starts with having an idea, creating a prototype, testing it, improving it, then repeat.
So, if you are thinking that it’s going to be a “one and done” type of situation, good luck. You will soon learn that the idea of just one prototype is nonproductive. Designers should be informed and learn from the feedback during testing of each prototype in order to make key improvements. Learning how users behave while using the prototype provides invaluable information and reveals possible problems. Doing this will bring the prototype closer to a final iteration that resembles the final product, system, or app. Fortunately, there are many options for prototyping tools that can help make the process faster. Some include: Invision, Proto, and Keynote. Also, you’ll find that some low-fidelity prototyping tools can move your prototype into a high-fidelity version.
Get started to get the most out of your prototype.
You can start by taking action! You have an idea, now start to build on it. The process will expose flaws in your thinking and help you see things through a real-world lens. Over thinking the design without moving towards the basis of a successful idea could kill it. So, don’t waste time. Act on the information, data, wireframes, and let the prototype begin! Here are some things to remember:
- Remember goals. As you build, be sure to keep project goals in mind. What is this app ultimately trying to achieve? And what makes this idea better than the competition? What types of problems could pop up during testing?
- Remember users. You will eventually rely on users to test your prototype so keep their needs at the forefront. What are you expecting users to do? How do you expect them to behave? Then see what revelations develop during testing.
- Be open to change. Once you begin and then as the feedback on your prototype comes rolling in, you’ll need to have an open mind. Sometimes what you thought would work best, didn’t take into consideration the user’s behavior or habits. Take comfort in knowing that ideas can evolve into even better ideas. The more you improve and enhance a bright and original concept, the greater chance for its success.
At the end of the day, your good prototype will bring you closer to realizing your idea and sending it into production. Do it right and reap the rewards!
Find out how Bitbean can help your company realize its goals by building amazing software.