Mental Models of Undo and Redo: Time in the Interface

Learn how users perceive time travel in digital interfaces through Undo and Redo models, and how to design them for complex collaborative environments.

info Quick Definition
Mental Models of Undo and Redo are how the user understands that they can go back or forward in the history of their actions. Correct Undo design reduces user anxiety, allowing them to experiment freely with the interface without fear of making irreversible errors.

The Power of Indulgence (Forgiving UI)

The “Undo” button is the most powerful psychological safety tool in interface design. When a user knows they have a “safety net” under their feet, their cognitive load decreases and their willingness to explore new features increases dramatically. Without Undo, the user becomes conservative and fearful with every click.

There are three main models of how the user perceives this time travel:

The 3 History Models

1. The Linear Model (Chronological)

This is the most common. Actions are stored in a stack one after another. When Undo is pressed, the last action is removed. If the user performs a new action after having undone several times, the “future” that had been undone (the Redo) is lost forever.

  • Use: This is the standard in tools like Word, Figma, or Photoshop. Users understand it naturally.

2. The Graph Model (Non-Linear)

In this model, the system saves all versions of history, even if the user takes a new path. Nothing is ever deleted.

  • Use: This is the heart of version control systems like Git. It is powerful for experts but confusing for the average user due to its visual complexity (branches).

3. The Selective Model

Allows undoing a specific action from the past without affecting actions that occurred afterward.

  • Use: Google Docs uses it partially. If I deleted a paragraph 10 minutes ago but continued writing elsewhere, I can try to recover only that paragraph without losing what I wrote after.

The Big Challenge: Collaborative Undo

In multi-user environments (like Figma or Notion), the mental model of Undo becomes enormously complicated. If my teammate deletes something and I press Undo, what should happen?

  • Global Undo: Undoes the last action in the system, no matter who did it. (Usually extremely frustrating and confusing).
  • Local Undo (Per User): Only undoes my own actions. This is the current technical standard, but it requires complex logic behind it (usually implemented with CRDT or Operational Transformation).

Design Best Practices

  • History Visibility: Offer a visual list of actions (e.g., Photoshop’s History panel) so the user knows exactly what point in time they are returning to.
  • Action Granularity: What counts as “one action”? If I type a word, is each letter an Undo? No. Group small logical actions so that Undo is useful.
  • Visual Feedback: When the user presses Undo, clearly show what has changed. A subtle blink or an entry/exit animation helps the user’s eye find the difference.
  • Direct Access: Always keep the universal standard of Cmd/Ctrl + Z. Don’t try to reinvent the Undo keyboard shortcut.

Mentor’s Tips

  • Don’t limit Undo levels: If system memory allows, let the user go back as far as they need. “10 levels of undo” are a technical relic of the past.
  • Undo as a life-saver on mobile: On touch screens, where accidental errors are more frequent, having a visible “Undo” button or a quick gesture is pure gold for usability.
  • Involve Engineering: Implementing a robust Undo system is a first-rate technical challenge. Be sure to understand the limitations of your architecture before promising complex selective Undo.

Useful Resources and Tools

command-pattern crdt-for-designers conflict-resolution prevention-vs-recovery-errors