Undo and redo: what Cmd+Z covers, and where it ends

Cmd+Z undoes, Shift+Cmd+Z redoes (Ctrl on Windows). It works in the grid the way it works in a document — but a database is shared, so the edges are worth knowing exactly. This page is those edges.

What one step is

The stack records your record-level actions in this table, 50 steps deep:

• A cell edit — undo puts the old value back.
• A create — undo sends the new record to the trash; redo restores it.
• A delete — undo restores from the trash; redo deletes again.
• A restore from the trash modal — undo re-trashes it.
• A multi-cell action — a paste, a fill-handle drag, a range clear — is one step. Cmd+Z takes back the whole block at once, the way a spreadsheet would, not one row per press.

Any new action clears the redo side — history forks forward, same as everywhere else.

An undo is a real write. It goes through the same path as the edit it reverses, which means it saves to the server, other people see it, and a webhook watching the table fires for it like for any other change.

Where it honestly ends

It's your session, in this table, in this browser tab. The stack lives in the open page: reload the tab and it's empty. Switch to another table and that table has its own (also starting empty) — coming back doesn't revive the old one. Nothing about undo is stored on the server.

Another person's edit isn't yours to undo. Cmd+Z replays your steps only. And if a teammate edited a cell after you did, undoing your edit there would silently erase theirs — so Tabla refuses it instead: the strip says "Changed since that edit — undo skipped," the grid shows the latest value, and that step is dropped. The same protection every write gets (editing together) applies to undo, because undo is a write.

Some actions were never on the stack. Field and table changes, attachment uploads, imports, and choices added to a select while editing are not undoable — the grid says so in the trash's own footnote. Structure has its own confirmations instead (deleting and what comes back).

While you're typing in an editor, Cmd+Z is the text field's own undo — it fixes your typing, not the table. The grid's undo takes over once the editor closes.

The safety net under the safety net

Undo is a convenience with a session's lifespan. The durable protection for deletes is the 7-day trash: a deleted record is restorable from there whether or not the tab that deleted it is still open — including by Cmd+Z's cousin, the Undo button on the notice that floats for 8 seconds after every delete.

The questions people ask

Is there an undo button? Only the one on the delete toast. Everything else is the keyboard — Cmd+Z is the button.

What happens if an undo doesn't reach the server? Nothing, and it says so: "That didn't reach the server. Nothing was undone." The step stays on the stack, so once you're back online the same Cmd+Z tries again. History never drifts silently.

Can undo half-apply? A multi-record step where some rows changed since (a teammate edited two of the fifty you pasted over) reverts the rows it still can and tells you: "Some rows changed since — undo only applied to the rest." Their newer edits stay theirs.

Can I hold Cmd+Z to rewind fast? Steps apply one at a time — each waits for the server to confirm before the next fires. A held key won't outrun what actually saved.