Skip to content
Expert Guide Series

The Thing About the Self-Serve Coffee Machine at the Service Station

The self-serve coffee machine at a motorway service station asks for about nine decisions before it hands you anything to drink. Cup size, then bean, then strength, then milk and which kind of milk, then sugar, then syrup, then whether you want a lid. The screen is bright, the buttons are big, and on paper the whole thing is simple. Yet there's nearly always somebody standing in front of it pressing back, starting again, half-watching the queue that's formed behind them.

A screen can be perfectly clear and still ask for more than the moment allows.

No single screen on that machine is badly made. The type is large, the touch targets are generous, and a nine-year-old could read every word. What fails is the match between the machine's idea of the moment and the actual moment, which involves a service station, a car full of people, forty minutes left of the drive and a stranger waiting for their turn.

That gap is cognitive load, and it's the same gap we've spent years designing around, including on an accident reporting app we worked on for BMW where the stakes were rather higher than a flat white. This article walks through what load actually is, where it comes from, and the specific moves that lower it.

What Actually Went Wrong at the Coffee Machine

Take the machine apart screen by screen and each screen holds up fine. What goes wrong sits in the sequence and in the quiet.

The order is the first problem. You're asked to pick a bean before you've been shown a price, and you're asked for a size before you know which sizes it still has cups for. So you're making early choices while holding an open question about the later ones, and holding open questions is exactly the thing people are bad at.

The quiet is the second problem. After you tap "oat milk", nothing confirms that oat milk is now part of your drink. There's no running summary anywhere on screen, so your own memory has to keep the order. When the back button jumps you two steps instead of one, that memory is all you've got, and it's already thin because somebody behind you just sighed.

The third problem is that the machine offers a kind of control nobody standing there wants. Strength settings and syrup pumps matter to somebody, somewhere, on a slow afternoon. At eleven minutes past seven in the morning, they're work. Each extra option is another decision the person has to make and then remember making.

Cognitive Load, Defined Without the Jargon

Cognitive load is the amount of thinking a person has to do to get through what's in front of them. Working memory is small and it empties fast, so people can hold only a few live pieces of information at once before something falls out.

It works a bit like carrying shopping bags from the car. You can manage three or four. Hand somebody a fifth and they don't drop the fifth, they drop whichever one has the eggs in it. People under load lose things in the same unpredictable way, and the thing they lose is often the bit you most needed them to keep.

Load isn't the same as difficulty

A hard task with one clear step is light. An easy task with six steps, two of which depend on something you read four screens ago, is heavy. Teams often measure difficulty and assume they've measured load, which is why a flow can test well with a specialist and fall apart in a car park.

The useful question is never "is this simple?" but "what is this person holding in their head right now, and how much of it did we put there?"

UX/UI design built around real psychology

We design app interfaces around how people actually think and behave. User research, psychology-driven UX/UI design and technical specs delivered as one complete package.

See how we work Get started

No commitment

The Three Loads: Task, Interface, and Everything Else Going On

It helps to split load into three sources, because you have very different amounts of control over each one.

LoadWhere it comes fromAt the coffee machineYour control
The taskWhat the person is genuinely trying to doChoosing and paying for a drinkLow
The interfaceHow you've arranged the askingNine screens, no summary, odd orderHigh
Everything elseThe room, the queue, the clock, the moodKids, motorway, stranger waitingNone

The task load is mostly fixed. Booking a hotel room needs dates and a room type, and no amount of design removes that. The third load is fixed too, and it's usually the heaviest. Somebody opening a skincare app at midnight after a bad week brings all of that with them.

The interface is the one load you control, so it should carry as little as you can make it carry.

That's the whole discipline, really. You can't make the motorway quieter and you can't make the accident unhappen, so you take weight out of the only place weight can come out of. Every button, label, field and option is either helping with the task or adding to the pile.

Why Step Order Matters More Than Step Count

Teams tend to count steps because steps are easy to count. Four screens feels better than seven, so the work becomes squeezing seven into four, and the result is four screens that each ask for a lot and explain very little.

Order does more than count does. A step that arrives when the person already has the answer in their head costs almost nothing. The same step arriving early, before they know why they're being asked, costs a lot, because now they're answering and wondering at the same time.

One exercise we run on this is simple enough to do in an afternoon. Go through every single piece of information on a screen and ask what it's doing there. Think about the use case, the emotional state somebody's likely to be in when they arrive, and whether that piece of content adds to the experience or just adds complexity. If there's a more sensible point later in the journey to introduce it, move it there.

Mark each field on a screen with the moment it actually becomes relevant. Anything whose moment hasn't arrived yet belongs further down the journey.

Shipping options shown before a size has been picked, loyalty sign-up offered before the first purchase, delivery notes requested before the address exists. Each one is a question asked out of order.

The Cost of Silence: Feedback, Confirmation, and Knowing Where You Are

When we worked on the fleet and rental vehicle side of the BMW accident app, the part that kept failing was the damage photos. The screen said "upload your photos" and then went quiet. People had just been in a crash, and they were being asked to work out which angles mattered, how many to take and when they'd done enough, with no response from the product either way.

Submissions came back incomplete, and the team couldn't work out why people weren't filling it in properly. The answer was that nobody ever told them what filling it in properly looked like.

Silence transfers the work

Every moment a product says nothing, the person has to generate the answer themselves, which means holding their own progress in working memory while they carry on. Confirmations, summaries and specific error messages hand that weight back to the interface, where it belongs. Precise errors are rarer than you'd think. Baymard Institute found that 98% of sites don't use adaptive error messages that say exactly what's wrong and how to fix it.

Telling somebody "that didn't work" leaves them to diagnose it. Telling them "the card expiry year is in the past" ends the problem in one line.

Designing for People Who Are Already Overwhelmed

Stress makes people forget well-learned ideas and information. Rational thinking drops away, and a task that's genuinely simple on a normal day becomes hard. That's the state the BMW app was designing for, and it's the state a lot of lifestyle products meet more often than they assume. A supplements reorder at 1am during an illness is not a calm moment either.

Time pressure alone does measurable damage to the quality of people's choices. A meta-analysis of more than 80 studies published in Psychological Bulletin found it reduces the probability of selecting the optimal solution by 25 to 40 per cent, depending on how complex the task is, with the biggest falls on anything needing abstract reasoning.

So on the redesign we stopped waiting for people to come and find us. We used the accelerometer to spot a sudden stop after a period of movement, and the app asked first: have you been in an accident? That took one whole task off the person, which was remembering the app existed, opening it, and locating the right button while shaking.

Reaching for the user is often cheaper than teaching them where to reach.

Asking Only for What You Need Right Now

The rule we work to is to ask only what's needed in the current moment. If something can wait until later, it waits.

That sounds obvious until you look at a real form, where the reason most fields exist is that somebody internal wanted the data and no one asked when. Marketing preferences, profile details, referral sources and optional notes all pile onto a moment that was already full.

Ask for what the next ten seconds need, and leave the rest for a calmer moment.

On the accident app we split the content of the old form by urgency, and most of it turned out to be things an insurer could collect later by phone or email. What genuinely had to happen at the roadside was small.

Here's roughly how that sorting goes on any journey.

  • Needed to complete this action at all, so ask now
  • Needed to complete it well, so offer now with help
  • Needed later in the relationship, so ask later
  • Wanted by someone internal, with no user benefit, so question it hard

Paring back is only half of it. The other half is actively taking work off people, guiding them through rather than expecting them to manage alone.

Choosing a Different Input: When Typing Is the Wrong Request

The old BMW product asked people to type up witness statements at the scene. Typing is slow, it needs spelling and sentence construction, and it needs you to decide what's relevant while you're writing, which is three jobs stacked on a person who's just been hit.

We replaced it with voice. People recorded statements that were transcribed automatically, and we kept the original recordings as well so the human nuance in the language survived, the pauses and the way somebody actually described what happened. We also let them answer the structured questions out loud rather than tapping through fields.

For the photos, we drew diagrams. The app showed exactly which angles to capture, one at a time, so it became a visual walk-through rather than a memory test.

Before adding another text field, check whether the same answer could come from a tap, a choice, a photo or a voice note. Typing is the most expensive input you can ask for.

Match the input to the body

Hands shake, screens get wet, one arm is holding a dog lead. Picking an input that fits the physical situation lowers load before a single word of copy is written, and it tends to improve the quality of what you get back.

Releasing Information at the Speed People Can Absorb It

Progressive disclosure is the habit of showing what's needed for the current step and holding the rest until it's relevant. It's less about hiding things and more about timing them.

Research cited by Nielsen Norman Group, reported in this roundup, puts the effect on task completion time at 20 to 40 per cent faster, with comprehension improving at the same time. Both parts matter. Speed on its own can mean people rushing past things they haven't understood.

Layering works because it keeps the number of live decisions low. A hotel booking that asks for dates, then rooms, then extras, lets somebody finish and forget each answer in turn. The same booking showing all three at once makes them hold the lot.

Two things keep layering honest. Credibility needs the serious information to stay visible, so a supplement's ingredients or a skincare product's contraindications can't be buried three taps down for the sake of a tidy screen. And people need to know more is coming, so a step count or a short line about what happens next stops the layering feeling like concealment.

Oversimplifying causes its own anxiety. The aim is the right amount at the right moment.

Fewer Things, Done Properly

A product with six features done carefully beats a product with fourteen done at eighty per cent. Load comes from breadth as much as from screens, because every extra feature adds menu entries, settings, empty states and edge cases, and all of that has to be understood by somebody.

Our standing advice to travel teams is to leave offline support out unless the product genuinely depends on it. It's expensive, it's hard to get right, and a half-working offline mode creates more confusion than no offline mode at all. The budget goes further spent on executing the core journey properly.

People are far less likely to come back after a bad experience, and they rarely separate "this one feature was rough" from "this app is rough". The weakest thing you ship sets the impression for everything else.

Features have a running cost

Maintenance is part of it, but the attention cost is bigger. Every feature competes for a sliver of the same working memory you're trying to protect, which is why pruning a product often lifts the parts you kept. Choosing what not to build is design work, and it's usually the highest-leverage conversation in the room.

Why Your Team Finds It Easy and Your Users Do Not

Your team has the whole product in their heads. They know what the third tab does, why the pricing is structured that way, which button leads where, and what the brand is for. None of that exists in the mind of somebody who arrived from an ad ninety seconds ago.

Your team carries the whole product in their heads, which is the one thing your users don't have.

This shows up clearly when stakeholders point at a competitor and call it intuitive. Part of what they're describing is that they understand what that product is for, and that understanding bleeds out into how every individual feature feels. The mechanics of the flow are doing less work than the frame around it. Strip the context away and the same interaction design feels confusing.

Which is why copying a competitor's checkout rarely delivers the competitor's checkout. You've taken the surface and left behind the comprehension that made it feel easy.

The practical move is to keep somebody on the project who hasn't learned the product, or to test with people who've never seen it, often enough that you don't drift. Familiarity builds up quietly, and after a few months nobody on the team can see the coffee machine any more.

How to Tell Whether Someone Is Struggling or Just Slow

Slow isn't a problem by itself. Someone reading a returns policy carefully is doing the right thing, and someone comparing two moisturisers for four minutes is engaged. Struggle looks different, and it has a particular signature.

In a high-stress environment, the problem shows up as lower comprehension. People can find the button perfectly well. What they lose is the understanding of what process they're in and what it's for, because they're operating emotionally and the logical thinking has gone. When comprehension of the task drops, and not just the execution of it, you're usually looking at stress rather than a layout fault.

In testing, ask people to say what they think will happen when they tap, before they tap. Wrong predictions are a comprehension signal and they appear much earlier than failures do.

Error rates tell a similar story. Lots of mistakes in a product often means you're overloading people with information and they don't fully understand what's being asked. The BMW fleet app showed this in the clearest way, because people were finding the damage form and completing it wrongly, which is a comprehension problem wearing the costume of a compliance problem.

Measuring the Point Where People Give Up

Analytics won't tell you somebody felt overwhelmed, but it will tell you exactly where they stopped. Onboarding is where this reads most cleanly. Ask for too much and people drop out of the process rather than push through it, and the drop sits on one specific screen.

Patience is shorter than teams expect. Think with Google reports that 21% of users give up on an app if they don't get it right away, which puts most of your explaining inside the first minute.

Four numbers are worth watching together, because any one of them alone is ambiguous.

  1. Step-by-step drop-off through onboarding and checkout
  2. Time on the specific screens where drop-off spikes
  3. Error and correction rates per field
  4. Back-navigation and repeat visits to the same screen

Time on screen rising while drop-off rises is overload. Time falling while drop-off rises is usually a mismatch, where people arrived, read the headline and decided it wasn't for them. The second one is a positioning fix, so it helps to know which you're looking at before anyone starts redrawing buttons.

A Practical Audit: Walking Your Own Journey Cold

The cheapest useful exercise is to walk your own journey as though you've never seen it, on a real device, in a realistic setting. Not at your desk with two monitors. On a phone, one-handed, somewhere with noise.

  1. Pick one job, like a first order or a rebooking, and write down what a new customer actually knows at the start.
  2. Go through it and note, on every screen, each piece of information and what it's doing for that moment.
  3. Mark anything that can be moved later and move it.
  4. Mark every point where the product goes quiet and add a confirmation, a summary or a specific message.
  5. Count the decisions. Then remove the options nobody in that moment wants.
  6. Run the whole thing again with somebody outside the team watching, and ask them to predict each step before taking it.

Two hours of this usually finds more than a month of debate, because the problems stop being theoretical. You feel the point where you'd have put the phone down.

The hardest part is honesty about the fields you've been told are mandatory. A good number of them are mandatory for a report that nobody reads, and asking who needs that data and when is a design question as much as a business one.

Conclusion

The coffee machine is designed for a version of the moment that rarely exists, with a calm person, a short queue and an interest in syrup. Real moments are busier and noisier than that, and the gap between the two is where people give up.

Everything we did on the BMW accident app came from the same handful of moves. Ask only for what the moment needs, guide people through rather than expecting them to manage alone, pick an input that fits the state they're in, show enough to be understood and hold the rest, and never go silent while somebody's waiting to know if they did it right.

None of it requires a rebuild. Most of it is sequencing, deletion and better feedback, which is why the work tends to pay for itself quickly. The products that feel effortless are usually the ones that quietly took the work off you.

If you've got a journey where people are dropping out and you can't quite see why, we'd be glad to look at it with you. Let's talk about your onboarding and checkout flow.

Frequently Asked Questions

What is cognitive load in plain terms?

Cognitive load is the amount of thinking someone has to do to get through whatever is in front of them. Working memory is small and empties quickly, so people can only hold a few live pieces of information at once before something slips. When that happens, they don't lose the least important item, they lose whichever one mattered most.

Isn't a simple, clearly designed screen enough?

No. The coffee machine at the service station proves it, because every individual screen is legible, well spaced and easy to read. What fails is the match between the machine's idea of the moment and the real moment, which involves a queue, a car full of people and forty minutes left of the drive.

How is load different from difficulty?

A hard task with one clear step is light, while an easy task spread over six steps is heavy, especially when two of those steps depend on something read four screens earlier. Teams often measure difficulty, assume they have measured load, and then wonder why a flow that tested well with a specialist falls apart in a car park.

Why does the order of questions matter so much?

The coffee machine asks you to pick a bean before showing a price and asks for a size before telling you which cups it still has. That forces people to make early choices while holding open questions about later ones, and holding open questions is exactly what people are worst at.

What does a running summary actually do for users?

It takes the job of remembering off the user and puts it back on the interface. When you tap oat milk and nothing confirms it, your own memory has to carry the order, which is fragile at the best of times and far worse when somebody behind you has just sighed.

Are more options always better for users?

No. Strength settings and syrup pumps genuinely matter to somebody on a slow afternoon, but at eleven minutes past seven in the morning they are simply work. Every extra option is another decision to make and then remember making, so control that nobody in that moment wants becomes a cost rather than a feature.

What are the three sources of cognitive load?

Load splits into the task itself, the interface you have built around it, and everything else going on in the person's world at that moment. Separating them is useful because you have very different amounts of control over each, and it stops teams blaming users for conditions the design never accounted for.

Does any of this apply beyond low-stakes tasks like buying coffee?

Very much so. The same gap showed up in an accident reporting app built for BMW, where the user is stressed, possibly shaken and standing at the roadside. The stakes are far higher than a flat white, but the underlying principle holds, which is that a perfectly clear screen can still ask for more than the moment allows.