Design undo and redo as part of the action
Make reversible actions understandable by naming what will change, showing the result, and giving a creative interface a clear path back and forward.
Reversibility is part of the interaction
Undo is often treated as a keyboard shortcut added after the main interface is finished. It is better understood as part of the action itself: what can change, how a person recognizes that change, and what it would mean to reverse it. A control that can be undone invites exploration, but only if the person can predict which change will be reversed and see that the reversal happened.
Apple’s Human Interface Guidelines recommend making undo results predictable and highlighting changes that are out of view. Microsoft’s Windows command guidance says a simple undo can suit reversible actions, while confirmation may suit consequential actions that cannot be undone. These are platform recommendations; your data model and the consequences determine the real boundary.
Name the change, not just the mechanism
A bare Undo label says how to act but not what the action targets. A contextual label such as “Undo crop” or “Redo title move” makes the next result easier to anticipate. Keep the description short and specific to the most recent operation. If the action changes something off screen, move attention to the result or otherwise reveal it; a silent change can look like a failed command and encourage repeated input.
This is also a hierarchy problem. Put a global command where people expect it on the platform; add a dedicated button when reversibility is central to the task. Avoid crowding the canvas. Consider grouping small adjustments to one property into a meaningful step, so the sequence matches how someone describes the work rather than how the application logs events.
Separate reversible work from external effects
A text edit, a moved shape, and a local color change are usually understandable as reversible states. Sending a message, publishing a file, or charging a card may affect people or systems outside the current canvas. Do not imply that reversing the local screen also reverses those external effects. Use a clear confirmation or a separate compensating action where the consequence calls for it, and state what that action can actually restore.
Define the boundary before drawing: does undo last until close, save, or longer? What if a collaborator edits the same object? Does a new edit replace the redo path? These are product rules, not decoration. A small state diagram can align the team before labels promise behavior the system cannot support.
Make the outcome visible and recoverable
An undo command should produce a perceptible change in the place where that change matters. Restoring a paragraph below the fold may call for scrolling to it; restoring a card may call for a brief highlight or an updated position in the list. Do not rely on a tiny status message if the user still cannot identify what changed. Redo needs the same clarity, because it reapplies an operation that may no longer be visible either.
Match feedback to the action. A quiet inline change may suit a local adjustment; a destructive operation may need a stronger review point. Show when no undo or redo is available, and preserve the person’s place when returning to earlier content. This supports exploration without turning each edit into a dialog.
Exercise: map a reversible poster edit
Draw a fictional event poster with a title, date, illustration, and two-color background. List four operations: move the title, crop the illustration, change a background color, and export the finished file. Mark which operations change the editable document and which create an external deliverable. For the first three, write the exact undo and redo labels, what should visibly change, and where the viewer should be taken if the result is off screen.
Now sketch three states: before the crop, after the crop, and after undo. Add a new color edit after undo and show whether the earlier redo path still exists. Decide what “export” means in this example: if it only creates a local copy, say so; if it sends a file elsewhere, do not show document undo as if it recalled that copy. This is a fictional interface exercise, not a report of user testing. Its purpose is to expose missing product rules while the design is still easy to change.
Try it yourself
- List the actions in the task and mark which ones the product can truly reverse.
- Write short contextual undo and redo labels for each reversible action.
- Sketch the before, changed, and restored states, including off-screen results.
- Test the history after undo followed by a new edit; document what remains available.
- Give irreversible or external actions their own honest confirmation or recovery path.
Worked example: a fictional poster editor
A designer moves a title and crops an illustration. “Undo crop” restores the previous crop and highlights the illustration; “Redo crop” reapplies it. If the designer undoes the crop and then changes the background color, the mockup must show whether redo is cleared or retained according to the product rule. Export is a separate operation: the interface should describe whether it saves a local file or sends a copy, and should not promise that undo will recall a delivered file. This invented scenario illustrates the design questions; it reports no product test.
References & further reading
- Apple Human Interface Guidelines: Undo and redo ↗
- Microsoft Learn: Commanding basics for Windows apps ↗
Examples and exercises in this guide are original teaching scenarios.
