Staging & commit

Item edits, creates, and staged deletes go through a staging area before they touch DynamoDB. Think of it as a git staging area with a safety latch: changes accumulate as reviewable diffs, then ship as only when you commit.

PartiQL INSERT, UPDATE, and DELETE statements go through the same stage: the run button offers Commit changes or Stage changes.

Some gestures skip the review pause by design: ⌘⇧S saves and commits an item in one step, ⌘⇧⌫ deletes the selected rows and commits in one step, and Commit edits or Commit delete in a bulk edit or bulk delete stages and commits every item in one step. Every committed write, one-step or not, lands in the write history.

How it works

Each table has its own staging area, shared across every view of that table. When you save an item edit, create a row, or delete one, the change lands in the panel as a per-attribute diff: added, removed, and changed attributes shown side by side. Affected rows in the grid are tinted by operation:

  • green: a new item (create)
  • orange: an update (changed cells highlighted)
  • red: a deletion (struck through)

Open the same table in two tabs and they show the same pending changes; close and reopen a tab and the stage is still there. Closing a tab never discards your staged changes.

Toggle the panel with ⌘⇧D. Drag its edge to resize it.

DynoTable's Pending changes panel showing DynamoDB changes as per-attribute diff cards, with per-row and bulk commit.
DynoTable's Pending changes panel showing DynamoDB changes as per-attribute diff cards, with per-row and bulk commit.

Reviewing changes

Each diff card shows exactly what will change:

  • Scalars render old → new with red/green highlighting.
  • Long strings show an inline word-level diff.
  • Maps and Lists render as pretty-printed JSON (whole-attribute in v1).

Use a card's per-attribute Reject to drop a single attribute back to its original value. Reject every attribute and the whole change is discarded.

Committing

Commit to write your staged changes to DynamoDB:

  • Commit N ships every staged change for that table, across all its tabs.
  • Commit just this ships a single change from its card.

Select rows in the Staged list to commit or discard only those, with Commit N selected or Discard N selected. When changes conflict, the conflicted ones list first and an All / Conflicts filter appears. With Conflicts chosen, the buttons become Commit N shown and Discard N shown.

Commits go out as TransactWriteItems batches with optimistic-locking conditions: an update only succeeds if the attributes still hold the values you started from, a create only succeeds if the item doesn't already exist, and a delete only succeeds if the item is still there. The expression builder on this site composes the same UpdateExpression and ConditionExpression shapes if you want to inspect them outside Pending changes. Large stages are automatically chunked to stay within DynamoDB's transaction limits.

The save chords from the editor apply here too:

  • ⌘S: stage (no commit)
  • ⌘⇧S: commit the item's changes
  • ⌘⇧X: discard all staged changes (with confirmation)

From a grid selection you can stage deletes without opening the editor:

  • ⌘⌫: stage a delete of the selected rows
  • ⌘⇧⌫: commit the delete of the selected rows

When every item a query matches is selected (⌘A on a query with more pages), both chords open the delete picker instead.

To change or delete many items in one pass, including every item a query matches, use bulk edit and bulk delete. A bulk edit stages one pending change per item, so it is reviewed and committed here like any other.

A direct run is the exception: it writes without staging.

Conflicts

Because commits use optimistic locking, a change committed by someone else after you staged yours is detected rather than silently overwritten. The card shows an inline banner:

  • Remote item changed: the remote item changed underneath you. Rebase onto remote refreshes the baseline so you can re-review, or Discard the change.
  • Remote item deleted: the item no longer exists. Discard the change.
  • Network/DDB unavailable: the commit couldn't reach DynamoDB. Retry, or discard the change.

A commit halts on the first failed batch: earlier successful batches stay written, the rest are not attempted, and the failures surface as conflicts to resolve.

Write history and Revert

DynoTable keeps a local history of every write that goes through staging: item edits, creates, and deletes, PartiQL INSERT / UPDATE / DELETE statements, batch deletes, bulk edits, and writes the AI agent staged for you. An import and a direct bulk run write through a separate path and are not recorded. Open the History tab of Pending changes (Pending changes) to see them.

Entries are grouped by commit. Each one shows the per-attribute diff (what every attribute looked like before and after) and how the write was made: an item edit, a PartiQL statement (with the statement text), a bulk edit, a value copied in Compare, the AI agent, or a batch delete. A batch delete records each deleted item in full, read just before the delete ran, so it can be brought back exactly as it was.

Revert stages the exact inverse of a write as an ordinary pending change. Revert a single item or a whole commit, then review the diff and commit it like any other change — a revert is never written silently. If the item changed in DynamoDB after the write you are reverting, the revert surfaces a conflict instead of overwriting the newer value.

The History tab of DynoTable's Pending changes panel: committed DynamoDB writes grouped by commit, each with its per-attribute before/after diff and a Revert action.
The History tab of DynoTable's Pending changes panel: committed DynamoDB writes grouped by commit, each with its per-attribute before/after diff and a Revert action.

History is local to this machine. It is a convenience for undoing your own writes, not a shared audit log — nobody else on the team sees it, and it keeps only recent commits. The panel says when older entries are hidden.

Three limits to know before you rely on a revert:

  • Reverting a create removes the whole item, including attributes added to it after that commit.
  • Reverting a batch delete restores the item as it was read before the delete. A write that raced the delete is lost.
  • Very wide items (about 150 attributes or more) cannot be reverted.

What blocks commits

Editing, staging, and committing all need a Trialing or Active license. A state blocks the whole path, not just the commit. It unlocks again once the app is back to an active state.

Updated