Usability testing is critical to project success which is why there are many different methods for conducting usability tests. The only problem is that most of these methods are incredibly resource intensive. You need to recruit test participants, make arrangements for conducting the tests, fill out paperwork, and much more.
An easy, cost-effective way to test your product’s usability is by conducting guerrilla usability tests. This testing method helps teams validate design ideas, interfaces, and product functionality quickly and at a low cost.
In this article, we’ll explain what guerrilla usability testing it, how it works, and when you should use it in your projects. We’ll also walk you through a step-by-step guide on getting started with guerrilla usability testing in your projects.
What is guerrilla usability testing and how does it work?
Did you know that you can find up to 85 percent of core usability problems just by observing five people using your application? If you were to go to a local cafe or coffee shop, you could conduct quick usability tests without using any special tools and get insight into your interface design. This is an example of guerrilla usability testing.
Guerrilla usability testing helps you evaluate how effective your project’s interface is by putting its visual design and functionality to the test and gathering insight.
Ideally, test participants are the application’s intended user base. However, unlike other usability tests, participants aren’t recruited (or briefed) for guerrilla usability testing in advance. Instead, those conducting the usability tests approach people in cafes, coffee shops, shopping malls, or other places and ask them if they’d like to participate in the usability test.
In simple words, guerrilla usability testing is an agile approach to testing which doesn’t require special tools or a large budget. Generally, test sessions take around 10 to 15 minutes in which the person conducting the test:
- Approaches a person and asks them if they’d like to participate in the test.
- Assigns the test participant a few task scenarios.
- Observes the test participant’s interaction with the application.
- Asks about their experience using the application and if they have any questions or feedback.
The great thing about guerrilla usability testing is that you’re able to get insight regarding your application’s interface, visual design, and functionality quickly without having to worry about recruiting test participants in advance and making necessary arrangements to gather insight.
Now that we have a good idea about what guerrilla usability testing it and how it works let’s quickly take a look at when you should conduct it. Then we’ll show you how to get started with conducting your own guerrilla usability tests.
When should you conduct guerrilla usability tests?
The short answer is that you should conduct guerrilla usability tests whenever you need a quick and cost-effective way to test your application’s usability. This could be at the prototyping stage or after the project is complete. That said, it’s important to keep in mind that you should test as early and as often as possible.
Here are some scenarios where it makes sense to conduct guerrilla usability tests:
- You’re at the prototyping stage and need a quick and easy way to validate design assumptions.
- You’ve missed a few project deadlines and need a quick way to conduct usability tests.
- You’re low on budget and can’t afford to recruit test participants or arrange for proper equipment.
It’s important to keep in mind that the data you gather from guerrilla usability tests isn’t always as accurate as other usability tests. For example, if you’re unable to find test participants that fit the application’s intended user base, your findings might be less accurate.
That said, if your application doesn’t require the user to be knowledgeable about a complex, lesser-known feature, then guerrilla usability tests can be incredibly effective. For instance, asking people to configure a caching plugin requires a working knowledge of web caching whereas asking people to book a flight for two adults doesn’t require the test participant to be knowledgeable on a challenging topic.
Getting started with guerrilla usability testing
As we mentioned before, when it comes to usability testing of any sort, it’s important to keep in mind that you should be testing as early and as often as possible. Fixing usability issues with a nearly complete product will almost always be more expensive than with a prototype.
With this in mind, let’s take a look at the steps you need to follow to get started with guerrilla usability testing.
Step #1: Determine what to test (and what not to test)
The first thing you need to do is jot down a list of tasks that users should be able to perform using your application. The list doesn’t have to be detailed. So, instead of Searching for a product using the search bar on the online store’s homepage without using any filters your task can be as simple as Searching for a product.
Once you have your list, you can decide which tasks you’d like to include in your guerrilla usability tests.
One way to do this is by assigning each task a priority level from 1 to 5 based on how frequently a user is likely to perform the task. For instance, if you were designing an interface for an online store, you might have the following tasks on your list:
- Creating an account (Priority = 1)
- Searching for a product (Priority = 5)
- Purchasing a product (Priority = 5)
- Contacting customer support (Priority = 3)
- Returning a product (Priority = 1)
Since users are likely to create an account once, the task’s priority is set to 1. Whereas Purchasing a product has a priority level 5 since that’s the main task users perform on e-commerce websites.
In the context of guerrilla usability testing, establishing a point system based on task priority is important because you can’t test everything at one time. Focusing on testing tasks that users will be performing most of the time will give you the most value.
Step #2: Shortlist your list of tasks to test and create scenarios
Now that you’ve assigned a priority level for each task, shortlist the tasks that you’d like to include in your guerrilla usability tests. Following our example, we might go with the following tasks:
- Searching for a product.
- Purchasing a product.
- Contacting customer support.
Next, create scenarios out of the tasks you’ve shortlisted, so test participants can understand and follow them.
When writing task scenarios, be careful not to use words that you’ve used in your microcopy. Doing so gives the user clues about what they’re supposed to do. Instead, phrase your task scenarios in a way that’s easy for the user to understand the task without guiding them through your main success scenario.
Additionally, be sure to give users all the information they need to complete their task and nothing extra. Extra information can be confusing for the user, and you won’t get accurate results.
Finally, it’s good practice to establish context wherever possible. By doing so, you’ll be able to engage participants by providing task scenarios that encourage action and are realistic. For instance, your task scenarios might be something like:
- You want to purchase a silk pillowcase for your mother. It has to match her sheets, so you’re looking for a navy blue set with a 400 thread count.
- You purchased a product four days ago, but it hasn’t yet arrived. According to the email confirmation you received, it was supposed to arrive yesterday. You’re a bit confused and want to clear up the situation. Go to the website and initiate a live chat with the customer support department.
Step #3: Conduct guerrilla usability tests
Now that you have some task scenarios in place, you can head over to a local coffee shop or cafe and begin testing. Approach people who fit your application’s intended user base and ask them if they’d like to participate in the usability test.
Most people you approach might not be familiar with guerrilla usability testing so start by offering a brief explanation of what this testing method is all about. Next, give them the task scenarios you’ve prepared and watch how they interact with your application.
It’s important that you don’t address any questions test participants have during the test or provide helpful tips on how to use your application. Let the tester figure out the task scenario and application interface on their own while you sit back and observe their actions.
Pro Tip: Encourage test participants to think out loud while interacting with your website. Their commentary will give you insight into what they’re thinking and might help uncover usability problems.
After the test, address any questions the test participant had while they were testing your application. You can also ask the test participant any follow-up questions you might have regarding the specific actions they took.
Step #4: Gather insights
Once the test is complete, you can gather insight using one of two methods:
One way is to jot down the top X usability problems you noticed while observing the test participant. For each test participant, simply list down the top X usability problems they encountered while using your website. Keep in mind that guerrilla usability testing is all about finding and fixing severe usability problems.
Alternatively, you can also use a point based system. Establish a tasks-testers matrix and use a point based system to document how easy (or how difficult) it was for the test participant to complete each of the tasks.
- If a test participant is unable to perform the task, mark it as 1.
- If they spend a lot of time on it, mark it as 2.
- If they can complete the task without any difficulty, mark it as 3.
The task scenarios with the lowest total sum will indicate the features in your application that needs to be fixed or have room for improvement.
Download the Guerrilla Usability Test matrix for your own projects.
Step #5: Fix the issues you uncover
By now you’ve conducted guerrilla usability testing, gathered insights, and developed a matrix to help you identify the most severe problems. All that’s left to do now is start fixing the issues you’ve uncovered.
If you were testing out prototypes, fixing problems shouldn’t take too much time. However, if you were testing out a nearly completed project, you’ll likely have to spend some time and money to fix the issues. We recommend fixing the most significant problems first and working your way down from there. If you’re following the matrix, start by fixing the problems with the task scenarios that have the lowest total sum.
If you’re short on time or working with a limited budget, guerilla usability testing is a quick way to observe user behavior and uncover core usability problems in your application.
Let’s recap the main steps you need to follow to get started with guerrilla usability testing in your own projects:
- Create a list of tasks and determine which ones you’d like to test by assigning each task a priority.
- Shortlist the tasks and create engaging, realistic task scenarios.
- Approach test participants in a local cafe and ask them to complete the task scenarios while you sit back and observe.
- Gather insights by jotting down the top usability problems, creating a matrix, or a combination of both.
- Fix the usability problems you’ve uncovered.
What types of usability tests do you run on your UI/UX projects? Let us know in the comments section below.