How to undo a mistake in a design tool

One keystroke for most mistakes

Most mistakes in Canvasola are a single action that needs reversing: a deleted node, a moved shape, a resized frame, a branch pasted in the wrong place. Ctrl/Cmd+Z reverses exactly that, and it is fast enough to use without thinking.

The undo and redo buttons in the top bar do the same thing and gray out when there is nothing left to go back to, so the buttons are an honest readout of where you are in the history. Redo works with Ctrl/Cmd+Y, and Ctrl/Cmd+Shift+Z does the same job.

Because the history stores whole document snapshots, an undo brings back the document as it was, not a partial patch. That is why undoing a big mistake does not leave half of the change behind.

• Ctrl/Cmd+Z reverses the last action in the active document
• Ctrl/Cmd+Y or Ctrl/Cmd+Shift+Z puts it back
• The top bar buttons gray out at the ends of the history
• An undo restores the whole document, not part of it

When undo is not enough

Undo is a stack of steps, and it has two limits that matter in practice. The history keeps 20 versions, so a long run of changes can push the state you need off the end of the stack before you notice anything is wrong.

The second limit is where the history lives. It belongs to the open document, and it resets when you switch to a different workspace tab, so a change you made in Canvas 1 is not in the history of Canvas 2 even though the two documents are related.

There is a third case: a change that was not an action at all, such as a document that opened incorrectly or a file that was imported badly. No keystroke reverses that, because the history only holds what happened inside the session.

• The history holds 20 versions, then the oldest one drops off
• The history belongs to the open document, not to the workspace
• Switching tabs starts a fresh history for the document you open
• Imports and opened files are not steps you can undo

Note: The guide to organizing multiple canvases explains why a tab switch resets the history, and the local autosave keeps the open document between sessions.

Open the version history panel

The version history panel is the second line of defense. It is the clock button next to the undo and redo buttons in the top bar, and it opens a list of the recent snapshots with the time each one was taken.

The newest version sits at the top of the list, so the state you are most likely to want is the first thing you see. Each entry also carries a label describing the kind of edit that produced it, which makes the list far easier to read than a column of bare timestamps.

Open the panel when undo would take you too far, not just when undo has run out. If you have made four changes and want to lose the last two, the panel lets you jump straight to the state before them.

1. Open the panel. Click the clock button beside undo and redo in the top bar, and the list of recent versions appears.
2. Read the list. Entries are ordered newest first and each one shows a time and a label, so you can spot the moment you want.
3. Pick a version. Click the entry you want. The document is restored to that snapshot and a short notice confirms it.

Restore the state you actually want

Restoring a version is not a dead end. The document returns to the state you picked, and you can keep editing from there, which turns a restore into a way of going back rather than a way of losing the work that followed.

Versions after the one you restored stay in the list, marked as later states, and redo can still walk forward through them. That means a restore is reversible too, which is worth remembering before you treat a snapshot as final.

The restored document is written to the local autosave straight away, so a reload does not undo your restore. What it does not do is create a new named copy, so if the older state matters, export it before you move on.

• The restored state is editable, not a frozen copy
• Later versions stay in the list and can be redone into
• The restore is written to the local autosave immediately
• Export the restored state if you need to keep both versions

Note: The history panel is per document, so the versions listed belong to the canvas or map that is open right now. A different tab has its own list, and the App Builder shares the host document's history.

Undo across three editors

One history covers the whole document. The canvas, the mind map and the App Builder all write into the same stack, so a change to a frame and a change to a drawing are undone by the same keystroke in the same order.

That shared stack is genuinely useful in a mockup session, where you move a frame, adjust a color and add a note in quick succession. It also means there is no separate undo for each editor, so you cannot take back a frame change without also taking back the drawing change that came after it.

The complete Canvasola guide describes the three editors and where their panels live, and the canvas organization guide covers the habits that prevent the mistakes in the first place.

• Canvas, mind map and App Builder edits share one history
• The order of the stack is the order you made the changes
• There is no per-editor undo to fall back on
• Ctrl/Cmd+D duplicates instead of undoing, so it is safe to try

Mistakes worth preventing

Some mistakes are cheap to undo and others are not, so it pays to separate them. A deleted node, a dragged shape and a recolored branch are all one keystroke away from being back, and worrying about them is wasted effort.

The mistakes that hurt are the ones that take a while to notice. A background at the wrong opacity, a layer left hidden, a whole branch deleted ten minutes ago, a mind map imported with the wrong structure. These are what the version history panel is for.

Prevention is mostly about the order of your actions. Save a project file before a large change, keep a copy of anything you imported, and check the layers panel when the canvas looks emptier than expected. The focus mode guide covers reviewing a canvas without the interface competing for your attention.

• Deleted or moved things: one undo, no drama
• Style and visibility changes: check the layers panel
• Large edits: save a .canv project first
• Imported material: keep the original file

A checklist you can reuse

• Ctrl/Cmd+Z and Ctrl/Cmd+Y are used to step back and forward
• The version history panel is opened from the clock button in the top bar
• The correct entry is picked by time and label, not by guesswork
• A restored version is treated as a place to keep editing
• The 20-version limit is known before a long run of changes
• Large or risky edits are preceded by a save with Ctrl/Cmd+S
• Imported material is kept in its original file

Common mistakes to avoid

• Undoing ten steps to fix one. Ctrl/Cmd+Z is cheap but blind. The version history panel takes you straight to the state you want, which saves the rest of the stack from being unwound by accident.
• Assuming undo crosses tabs. The history belongs to the open document and resets when you switch tabs. A change made in another tab is not waiting for you in this one.
• Treating a restore as final. Restoring a version puts you back in the document, and later versions stay available. Export what you need rather than assuming the restore settles the question.
• Deleting without looking at the layers panel. A hidden element is still in the document and still counted. The eye icon in the layers panel shows what is visible before you conclude that something is gone.
• Using undo for a decision you meant to make. When a change was deliberate, redo puts it back and stops the second-guessing. Check the intent before you revert anything that took a minute to set up.

Frequently asked questions

How many versions can I undo back through?

The history keeps 20 versions. Each action adds one, and when the stack reaches that limit the oldest entry drops off the end, so the deepest state you can always return to is roughly the last 20 changes you made.

Does undo work across the canvas, the mind map and the App Builder?

Yes. All three editors write into one shared history, so the same Ctrl/Cmd+Z reverses whichever editor the last change came from, in the order you made the changes. There is no separate history for the App Builder and no separate history for the canvas.

Can I get a deleted node back after switching tabs?

Not with undo, because the history resets when you switch workspace tabs. If the deletion is recent and the node was in the same document, the version history panel of that document can restore it, and the deleted branch is also worth checking in a saved .canv project.

Does the version history panel survive a browser restart?

The current document is kept in a local autosave, and the history belongs to the open session rather than to the saved file. A restart brings your document back, but the list of 20 versions starts again, which is another reason to save a project file before a risky change.

This guide is part of the workflow and productivity collection. For the wider product tour, read the complete Canvasola guide, and keep the keyboard shortcut cheat sheet open while you work.