Photo via flickr
Every now and again, we like to profile a user experience technique, to lift the veil on what UX designers actually do. Today, we’re looking at something called rapid prototype testing – what it is and the different shapes it can take.
Rapid prototype testing
Rapid prototype testing is a simple concept – it’s taking a quick and dirty prototype and testing it among a bigger group of stakeholders, designers, and end-users. The core idea here is that the more testing and feedback you get, and the earlier you get it, the better your end product is going to be.
Rapid prototype testing is really a product of a wider design approach called iterative design. This is where, instead of planning and building the ‘perfect’ product, you build in stages, testing, tweaking, and changing as you go. Because the reality is that any product you build is never going to be perfect the first time around. It takes designers trying something, saying ‘boy, this was a bad idea’ and then trying the next thing.
Rapid prototype testing is simply the physical manifestation of that design ethos, and the end goal is to present your audience with a product while still having the ability to take their feedback and fold it into the final actual product.
For example, let’s say you’re designing a website for a university. University sites have exceedingly complex information architectures, since the end users are so diverse (academics, students, parents) and the information they need to carry are often equally disparate (financial information, grades, portals, housing, campus life, resources, etc..).
Rapid prototype testing would allow designers to trial an information architecture concept (like filing financial aid under tuition) before fully committing to it. The result is a more intuitive product built for users, not for designers.
What is a prototype?
Now that we’re clear on what we’re trying to do with rapid prototype testing, the next obvious question is: what do we mean when we say prototype?
A prototype can be anything from a rough sketch on a piece a paper to a full on working hard coded product. Basically, there’s a sliding scale from low-fidelity to high-fidelity. Smashing Magazine splits this into three sections:
- Visual fidelity, ranging from basic sketched wireframes to more styled options.
- Functional fidelity, ranging from minimal functionality to an almost fully functioning product
- Content fidelity, ranging from lorem ipsum to actual content
For years, the reservations around prototypes have been that oftentimes, any code that was written couldn’t be reused in the final product. This made them time consuming and expensive to make, especially when you had to throw away all that work.
But advances like Bootstrap and Keynotopia, as well as a host of other hi-fi options, have mitigated this problem, making interactive prototypes faster and cheaper to make.
The result of these developments is that high-fidelity prototypes are increasingly attainable, which is a huge benefit for UX designers. The closer the prototype is to the final product, the more feedback that designers can gather from users and stakeholders, which in turn will lead to better insights about their product. That’s not to say that hi-fi prototypes are always the solution though.
Paper prototype testing
Paper prototype testing is as rapid as it gets. It’s using paper and getting a user to pretend it’s a computer, performing realistic usability testing tasks in order for UX designers to get an idea of what works and what doesn’t.
To mimic the software interactions, one designer’s job is to be the computer, so when the user taps something, they pull up the correct screen (piece of paper), while the other designer leads the usability session.
For rapid prototype testing, the benefits of paper prototyping are clear: it’s extremely fast, it’s very cheap, and changes can be applied very quickly, sometimes even before the next round of testing.
The downside, of course, is that it’s low-fidelity. When designers complete a paper prototype usability test, they’re asking the user to imagine quite a lot. This is fine and will definitely get high quality insights from users, but there’s always, always going to be gulf between imagined actions and actual behaviour.
Sum up
Rapid prototype testing is part of the broader iterative design ethos, where you build a product through multiple edits and versioning, constantly tweaking based on feedback from stakeholders and users.
Prototypes are tools that facilitate that rapid iteration, and can range from high-fidelity, highly functional prototypes, with lots of working code and real content, all the way down to paper prototypes, which are extremely low-fidelity, very inexpensive, and quick to produce and iterate on.
Both are valuable assets to the UX designer, and are a huge help to gathering user feedback early on in the design cycle.
