Users don't read (or even see) things. How can I deliver important clues?

Question

I am building a website. Some pages contain instructions (a few simple sentences, nothing intimidating) and have fairly standard controls (drop-downs etc).

There's not a lot on any one page. The presentation is about as uncluttered as I can make it, there is nothing particularly complicated or unusual going on, but I'm baffled by the first usability tests.

I've sat a few of friends and family in front of this thing and watched them interact and discover features. They're all familiar with computers and websites. These two problems crop up all the time:

• Users don't read things. I observe this. Also, they tell me: "I don't read things".

• Controls are invisible. Users ask me "where is such-and-such" and I point right into the centre of the screen. "Oh. There. Ho ho silly me."

I was prepared for my buttons and labels to be perhaps confusing or out-of-place. I wasn't prepared for the possibility that they'd be ignored entirely.

Other similar behaviours took me by surprise, for example if a piece of terminology surprises them they'll ask me what it is, but they won't click the link, the idiomatic blue link, which the word in question... is.

Usually, the feature is obvious to the users once it is pointed-out. Fairly self-evident in retrospect. I don't have much of a problem with the difficulty of the features, I have a massive problem of visibility. The users seem to be skimming over the controls and instructions assuming they're not important -- my design approach so far has been to put nothing on the screen which isn't important. Nothing can safely be skimmed.

Some pages have a linear flow of interaction and could be redesigned to expose one thing at a time -- stepping the user through -- which I imagine might work. Other pages are to be explored free-form, so adding such constraints makes no sense.

So here's my question: can someone please direct me to some design advice so I can make the user simply pay attention to what's right in front of them? To stop them skimming?

Answer 1

You are at least making a dedicated effort to involve users at an early stage, which is great.

As for the skimming behaviour, eye tracking studies have shown that these typically follow the same pattern on the screen. Jakob Nielsen has done a ton of research on it.

It strikes me however that there's a mismatch between your assumptions of what is "nothing intimidating, fairly standard, uncluttered" and the users' impression of it. If the users expect a certain element to be somewhere, but it is not where they expect it, or it's not called the same way, they get confused. It happens to me when switching between Thunderbird and the Gmail web site ('Compose' vs. 'Write' for a new mail).

You say that "Nothing can safely be skimmed". It does get skimmed however, and maybe because it doesn't look as if it's important?

It's hard to give any advice on a design I haven't seen, but I think the closer your UI sticks to conventions (yes, that means copying the big sites) the greater your chance of success.

Answer 2

The solution for this is called visual hierarchy.

It's damn hard to achieve.

My favourite example is found on the Thinking With Type website.

There are a few rules which help you to reach a visual hierarchy (Gestalt Principles, C.R.A.P. rules, etc), but in general, the person who understand this is called a graphics designer and the person who really understands it is called an excellent graphics designer.

So, in order to achieve this, you either have to hire a graphics designer, or become one, at least partially.

There are some good books on the topic (The Non-Designer's Design Book, Whitespace is not Your Enemy, Universal Principles of Design, etc), but in general, this is the topic which graphics designers should excel at.

Answer 3

First, "Nothing can safely be skimmed.". Here's the first clue. Make it safe. I'm not going to invest a lot of time in some unproven website, and learning to use it safely is not my priority.

Secondly, don't worry too much about users not finding what you want them to find. If they have a clear task in mind, they'll be motivated to look for clues. If they're asking you, that's because they perceive you as the best source for clues. That's an artifact of your test setup.

So, what you might just need is motivated users. That's a question all on its own.

Answer 4

Users pay little attention to the interface because humans are satisficing creatures. That is, they spend the minimal mental effort they expect to get away with, because that frees effort for other, more useful tasks.

Your options, then, are to

1. Make sure you don't willingly invoke satisficing, by making sure that errors and important messages are not confused for other, low-priority elements. Make sure that truly important errors do not look like advertisements (avoiding banner blindness) or significantly resemble other, less important UI elements.

2. Disrupt users using pop-ups or animations in peripheral vision. This is extremely distracting and should only ever be used if a particular user behaviour is truly mission-critical. I'm talking about material loss of some sort. If seen often, or if they rarely make the user change their behaviour, people will learn that the messages are low value and resume satisficing behaviour (i.e. automatically clicking 'OK' on popups like 'Are you sure you want to delete myImportantEssay.doc?'). Used sparingly, though, they can work.

3. Break satisficing by not providing a simple exit route from a page - think about dialogs that need the user to select something before they can be completed. This is extremely high-risk and needs to be deployed carefully; making sure users can defer the dialog or get back out if needs be, and that they do not need content outside the dialog to answer it.

4. Give up trying to model user behaviour around your domain content, and model the domain content around user behaviour instead - even if it means a less efficient workflow overall. Fit business rules to user behaviour constraints, not the other way around.

5. Don't create more than one point of focus in a piece of content. If you really believe that two different user groups have two different needs, create two pieces of content.

6. Finally, make sure stuff can actually be seen. This sounds obvious, but you'd be surprised how many people mess this up. Make sure vital content is discoverable. Make sure users can reasonably guess the nature of content below the fold. Don't hide stuff in hover statuses. Make sure there's a strong information scent and that links immediately belie their usefulness. Write content in a 'pyramidal' style, with the most important content first.

Answer 5

Totaly agree with @PatomaS there is not magic bullet to fix this problem. But it would be good to see wireframes or screenshots of your website. What kind of audience are you targeting? One way of making the user read the instructions is to make them interested in the product/service you are providing.

Use of colours and use of "terminal area" http://uxmovement.com/buttons/why-users-click-right-call-to-actions-more-than-left-ones/ ux movement website is down 30/10/12

Also what kind of website is it, why do you need alot of instructions? Take a look at the article by Joel Spolsky: http://www.joelonsoftware.com/uibook/chapters/fog0000000062.html

Answer 6

It might be helpful to have more clear indicators.

People don't click blue links for small things because they know it takes them away from the page, perhaps try hover tool-tips?

Try reducing the number of items on a given screen, and try to keep bullet points brief. Keep it structured, avoid long blocks of text without visual breaks. Use images intermittently to give the brain a break while still keeping it on topic.

If you look at how your post was structured, your content is staggered through negative space. You do this to encourage readability, your brain breathes. Clearly they feel smothered in information.

Answer 7

The way you present your problems excites all the usability engineering gist.
Let's say a few.

1- Users don't read things:
Of course they don't. They are presented a GUI where they should be able to click and move on.
To me, if the users need to read explanations then something is wrong with my UI. Nobody, not even me, will read an explanation up-front. The usual reaction to a control with an unknown outcome is to try it or paralyze depending on personality.
The best solution is to set the UI so the users don't need to read explanations. The labeling of the controls must make plain clear which is the purpose of the next control or controls set, in terms of the user (more on this below).
A must is to make clear to the users that they can undo any unexpected outcome. This moves a lot of people from the paralysis to the try group.

2- Controls are invisible:
When a user looks at a screen (or whatever interaction context) he looks at the whole screen but is focusing on a small part of it. Everything else is invisible (unless it's blinking in which case it excites peripheral vision).
So I guess that your users are not focusing on the right control. Or, they are but the right control doesn't look so right.
There are a few ways to handle this. One is making a wizard which you are already considering. Other one is developing a good hierarchy as aadam suggests. A third one would be to think about why that control is so invisible. Maybe its labeling is wron, like for example not in the domain language (more on this below). Or, this next step fits the implementation model of your system but contradicts the user's mental model. We already know that usability stems mainly from the fit between the manifest model (the UI) and the user´s mental model. May be your users are expecting to see next one thing but are presented with other. Like, a contrived example, they expect to see the total anount bebore being asked for the credit card number, because this is how it works.

3- ... nothing on the screen which isn't important
Important, for whom? In the UI things are important for the user, while we software engineers are prone to label as important the things accordint to the impact they have in the system, or the effort it took to develop them.

4- Watch your language! One way to make things invisible, or to make them not-important is to label them using internal wording. For example, during decades IBM labeled it's consulting offering Global Services (which is how tehy call it) and were surprised because nobody clicked there albeit it was their biggest business area, multi-billion.
Ask the users how do they call things, and use those names as labels.

5- The most important advise
If they do it wrong, blame yourself. In fact, avoiding the blame thing would help, think of learning from the users.
I know a lot about development software, but my users know waaay more than me about it, whatever is it.
And keep in mind that Einstein would also have flopped with your UI.

Answer 8

I wrote an article awhile back titled, Users Don't Read. You're absolutely right that users tend to skim, and you have to account for that in your design.

I have a few tips to address the problems you mentioned:

1. Simplify everything and make it as concise as possible (I talk about this in the article above). Sometimes this means rewording, or simply removing a lot of content. For instance, instructions are a classic example because so many people don't read instructions. Web interfaces have an edge over the instructions that come with your IKEA furniture, however. That is, web interfaces can be interactive. So if you can, don't put all of your instructions in one place. Instead, link to the first step and then guide the user from there through your interface one step at a time.
2. Break up long paragraphs of text with subheadings so that users can quickly focus in on the subject that pertains to them.
3. Follow design conventions common to the most popular sites (Google, Amazon, etc). Make your links look like links and your buttons look like buttons. Put your login / my account button in the upper-right corner. Make your logo link back to the homepage. And so on.