4 reasons why developers should attend usability testing sessions
Developers should be present on usability testing sessions from the very early stages, even when testing has been made on paper prototypes and mock-ups.
Very important fact here is that usability testing should start as soon as possible in the process. This means that it’s extremely crucial to identify the problem in initial phase, before you start with development. Most of the testing should be happen with mock-ups and prototypes, whether they are low fidelity prototypes or even high-fidelity interactive prototypes in later stages.
Low fidelity prototypes are great because they give us the focus on the concept and functionality itself, rather than on the details – which are better handled in one of the next phases of the design process. The other advantage is that they also take less time, which means it’s very easy to correct the mistake and solve the problem.
Spotting the problem in design early in the process is cost effective as well. Developers work is very expensive, and you want developers to actually develop rather than spend their time fixing the imperfections. And besides that, it would be extremely expensive to do the redesign, take the existing code out, code again with new design and finally make sure that the new code works properly.
It’s well known that developers don’t really prefer when they see the changes that have been made in a design. They feel like they are doing unnecessary work over and over again, which should be easily avoided in the first place. And I agree with that as well. To fail quickly and early in the process is the key for a good project!
The fact is that everybody should attend usability testing sessions, not just designers and developers. Project managers, product owners, business analysts, entire team should be present to see, hear and feel when the user succeeds or fails in completing the given scenario.
1. Real time users
When doing user testing, we always prompt participants to think aloud and to let us know how they feel when they are e.g. completing the form, uploading the document or sending a message etc. We want to know what are they expecting when they click the exact button, how are they feeling when the certain action happens and what would they change if they can. When developers are there, they can understand the problem better (if it exists) and see what that means for a user. This situation is for all those times when the things developed are different from the things that are designed.
For example, they might think that a certain feature, a button size or its position is not so important, but if a user cannot find a way to send a message because the button position is not on the place they expect it to be, they will struggle, loose the patience and in the end have a bad experience. And all because of the small thing that can be easily avoided in the first place.
2. New solutions
Other reason why developers should attend usability sessions would be because of the ideas they can generate observing the users. For example, we had a situation when we presented a prototype form to our users with an assignment to fill it an as they are applying.
The feedback was absolutely great on the entire user interface and functionality, the form had a conversational approach and it was very simple to use. We had only one question per screen and they could focus easily. The only complaint they had was around the speed of the transition between screens. So, 3 out of 5 users said it was too fast and they didn’t even notice they were on the next screen.
On that same session, one of our developers suggested that we can slow down the transition between the pages when we start with development. He also pointed out that we can add a button animation, ripple effect or similar, so they have a feedback when they click. It doesn’t require a lot of work, but it gives a lot of value.
It was a great experience because we all felt like a good team, all of us working together and for the same goal – build things that our customers will use without any difficulties.
3. Emphasise with the user
Sometimes it happens that developers don’t completely understand the reason behind the designer’s request. That can also be avoided by including them in usability testing sessions.
At some point they might think there is no sense in building the certain feature because it won’t bring value, or it’s too similar to existing one. But when they hear the real reason from the real users and their feelings and thoughts, developers can put themselves in their shoes and figure out along with the designer what’s the best solution to make the best experience for a user.
For example, we had a similar situation on the previous project when one of the developers didn’t see the difference between using the appropriate keyboard for email input and the default one. I asked him to join us on the next usability testing session where we tested an entire end-to-end flow.
He was a bit sceptic at first, which is always normal in those situations when people are attending the sessions for the 1st time. Then we started with the first participant, and we got the feedback straight away! Users don’t like extra clicks, actually – users hate extra clicks. Every time they tried to type in their email address, they had to switch between keyboards, look for “@” sign, and then again in order to put “.com”.
They were angry and felt like they were wasting their time, and my colleague developer realized he was wrong. He understood the importance of using the proper keyboard and what does it mean for our user. He also became more conscious about the future requests made by designers, and gave more importance to them because he knew that we don’t ask for anything without a specific reason behind.
The most important thing that I would like to highlight here is the fact that – if developers attend usability testing from the very start – this would completely affect the way they work. They would to be more eager to fix the problems when they feel the compassion for the user. It gives a lot more meaning to their work.
4. Seeing the bigger picture
It’s quite different to do something without knowing the reason why you do it, it’s like tapping in the dark and using no brain or whatsoever. Instead, on the other side you see the entire story behind every single designed screen, why are they in that particular order and why are they made in that way. Behind every “Why?” there is a proper “Because”, supported with user’s actions, positive and negative feedback and the good and bad experiences they previously had.
In the end, we all know that it’s all about the users. And it’s all about making them happy and careless when they are using our program, app or a service. Bad user experience can be avoided from the start, and usability testing is the right tool if we want to skip that part.
You don’t want to end up having a final product that constantly crashes, or has bad reviews and people actually hate it. Much better option is spotting the problems early in the start, and with having designers and developers included in usability testing in the early stage – a lot of things can be resolved. Developers can give us a great feedback as well, from the technical side of the e.g. an app.
For example, imagine the scenario where business decides to have a specific feature in the task app, a separate counter of the tasks that are marked as “Done” and “To-Do” ones. Designer does his part of the job, designs it and puts it in front of the user. In this case, let’s say that our users don’t have a reaction on the feature, in fact they don’t even notice that it’s there.
Developer, in that case, can give us a feedback from the technical side and say: “Well, from my perspective, this requires a lot of work. I’m going to spend 5 days in order to build this feature. On the other side, we can see now that user doesn’t even notice this feature nor appreciates it. Let’s try to propose something that requires less work and adds more value to the customer.”
And that’s the best thing. Have a feedback from a user and from the technical side in the real time and all at once. Helps us to make better decisions and act faster, because the time is precious and there is no sense in wasting it if we can use it better!
So, yeah! Invite your developers to join you on usability testing sessions. It helped us a lot in our projects, and it helped them as well because now they have a different approach to their work. And in the end, it’s all about collaboration and the team work!