Someone taps Save. Nothing seems to happen. They wait a moment, tap again, then give it one more go.
I can understand the third tap. There is something annoying about pressing a button and getting absolutely no indication that it noticed. You start wondering whether you missed it, whether the screen froze, or whether you were supposed to do something else first.
From the other side of a design review, though, those three taps can quickly become a story about a confusing button. I would be reluctant to start there. The person found it. They pressed it. They apparently expected something from it. That gives me a few questions before I reach for a different icon or a brighter colour.
Let's imagine a little app for saving places to visit. This is a made-up example, but the awkward moment is easy to picture: you find a place you like, tap Save, and sit looking at exactly the same screen.
What am I waiting for here?
In that situation, I would probably expect something quite small. The word could change to Saved. The icon could fill in. A short message could tell me the place had been added to my list. I don't need a celebration. I need to know whether I can move on.
If the app takes a couple of seconds to finish, some sign that it has started would help too. Otherwise, the screen is asking me to wait without telling me that waiting is the right thing to do.
That is why I wouldn't automatically read the extra taps as evidence that the person misunderstood Save. They might be checking whether the first tap landed. They might think the app missed it. They might be impatient. Watching the interaction doesn't give me access to their thoughts.
I would let them finish, then ask what they expected to happen when they pressed it. The answer could change the whole direction of the work. Someone who expected to download a map has a different problem from someone who expected a little confirmation beside the button.
Even the phrase “nothing happened” is worth unpacking. Nothing changed on screen? Nothing was saved? Nothing appeared in the list they opened afterwards? Those can feel like the same failure to the person using the app, while needing very different fixes.
Before getting attached to a solution, I want a better account of that small, irritating pause.
Three taps could still mean one save
For the coded version of this example, imagine that the first tap starts the save almost immediately. The app receives another tap about a second later and a third after two seconds. The confirmation finally appears at around two and a half seconds.
Now I want to know whether the extra taps did anything. Did we save the place three times? Did three requests go out, even though only one item ended up in the list? Or did the app quietly ignore the second and third taps while it was busy?
I'd pull up the tap and save records in RawTree to see whether those three presses actually became three requests. If only the first one did, I'd go back to the screen recording and look at what the person could see while that request was running.
For that to be possible, the prototype would need to record the taps, the requests they triggered, and when the confirmation appeared. A session code and identifiers connecting those actions would be enough to follow this particular attempt. I wouldn't need the person's name or the contents of their saved list.
Suppose the records show one request and one successful save. That would be reassuring about duplicate submissions, but the pause would still bother me. From the participant's point of view, they had to press three times before the app acknowledged them.
A neat “completed successfully” entry at the end leaves out the part that made them doubt what was happening.
I would also be careful about taking timings from separate systems and treating them as perfectly aligned. For this little example, I would record the interaction and response timing in the browser. Otherwise, a difference between clocks could make the sequence look stranger than it really was.
I wouldn't start with a bigger button
If the person found Save straight away, making it larger seems like an odd first response. I would rather try showing that the first press registered.
Maybe the button changes to Saving for the short wait, then Saved when the request finishes. Maybe the saved state appears somewhere else that is easy to notice. The details depend on the screen, but I would want to try the smallest change that answers the person's uncertainty.
There is a slightly awkward follow-up: what happens when saving fails? A button that says Saving forever isn't much of an improvement. I'd want to see that version of the screen as well, including how the person tries again or leaves without losing their place.
Simply making the button unavailable could stop the repeated taps. It wouldn't necessarily explain anything. I can imagine pressing a control, seeing it go grey, and being even less certain about what I just did.
The same goes for a confirmation that flashes somewhere far from where I'm looking. The app may technically have told me, but the test is about whether I noticed and understood it.
There is also the possibility that the button is fine and the saved list is the confusing part. If someone gets a clear confirmation and then cannot find the place afterwards, I would follow them to that next screen. The first control doesn't deserve all the blame just because it is easy to point at in a screenshot.
This is where I find the repeated taps useful. They draw attention to a moment worth watching more closely. They don't choose the redesign for me.
The next version still has to earn its keep
Before testing a change, I would check how much of this behaviour came from the prototype itself. A static mockup with a broken link can create a pause that a working app would never have. A coded prototype waiting on a real response gives the delay a different meaning.
I would keep a note of the version and what was actually connected. Otherwise, it becomes surprisingly easy to spend time improving something that only existed because the demonstration was unfinished.
For the next session, the task could stay simple: save a place so you can find it later. I wouldn't tell the person to press the button and wait for the new message. That would explain the change before I had a chance to see whether it explained itself.
Fewer taps would be encouraging, but I'd still want to know whether the person understood that the place was saved and could find it again. A quieter interaction isn't automatically a clearer one.
If the same person tries both versions, they also bring what they learned the first time. I would keep that in mind before giving the redesign all the credit. Someone who already knows that the app eventually responds may simply be more willing to wait.
The design note I'd want to keep would be fairly short. Here's the screen they saw. Here's when they pressed. Here's what the app was doing. Here's what they said they expected. We changed this part, and this is what happened in the next session.
I would leave room for the things we hadn't tried, too: a slower connection, a failed save, perhaps another input method. One tidy session wouldn't settle all of that.
What would make me happy with the revision is a person pressing Save once, understanding what the app is doing, and carrying on with choosing places. That is the moment I would want to see before calling the button finished.