Pressing a button and seeing nothing leaves too many hypotheses open. Did the command arrive? Has work begun? Should we try again? A brief interval can become a practical question before it even feels long.
Here I prepared a fictional operation: it waits one and a half seconds and displays a local outcome. It sends no files, contacts no server and does not measure your patience. The delay is a prototype choice; actual elapsed time can vary with browser execution. What matters is how the page makes beginning, waiting and completion recognisable.
Saying that something has begun
The control starts the comparison, changes state and prevents a second simultaneous start. During the wait, cancellation becomes available. At the end, the simulation is marked complete. The message stays on the page without opening a window or moving the point from which we were reading.
A declared wait
Ready. No data will be sent.
Without JavaScript: the sequence is Ready → Running → Complete; Cancel interrupts it. No real operation.
Initial feedback avoids asking users to interpret a void. It does not promise that an operation will succeed. It only confirms that the command was received and that the page is now doing the declared work.
The W3C document on status messages addresses making such changes available to assistive technology without requiring them to receive focus. In the prototype, the status is visible and can be announced. This choice does not certify the interface’s accessibility on its own; it at least prevents the change’s meaning from depending exclusively on a graphic signal.
How much we know about waiting
A percentage would be more precise information only if it described genuinely measured work. Filling one to accompany a timer could suggest control the system does not possess. Here we have no process divided into observable parts: we have a programmed interval. I declare it rather than turning it into a false prediction.

For a real activity, the question would change. We might know how many files have been processed without knowing how long the next will take; or receive an estimate that can fluctuate. Making waiting understandable requires distinguishing the data we possess from the reassurance we would like to offer. An elegant bar does not resolve that difference.
Stopping must leave a trace
Cancelling interrupts the timer and returns an explicit message. It is neither an error nor described as a success. The start button becomes available again: we can retry without wondering whether the previous attempt is still silently working.
Leaving the page interrupts the simulation; returning does not display an outcome left queued from a previous context. This too belongs to the control’s meaning. A simple comparison makes the problem visible, but a real save operation would require knowing what has already been written and what can actually be undone.
Giving the choice back
The end of the work must be distinguishable from the end of an animation. In this example there is no motion to watch until its final frame: there is text that changes when the timer ends. Success remains confined to the simulation, without pretending to have stored anything.
Between gesture and response, the interface’s task is to leave less room for unnecessary assumptions. We cannot remove every wait. We can avoid making people invent the system’s state while they wait.
