How versioning works in the semantic layer

Your semantic layer is shared. The measures, dimensions and joins in it feed every workbook built on top, so editing it can feel riskier than editing something of your own — one wrong move and you’ve changed what a room full of people are looking at.

Versioning is what takes that risk out. As you work, the editor keeps a history of your semantic layer: what changed, when, and who changed it. You can look back at any point in that history, compare it against what you have now, and bring back all of it or just the part you want. Nothing you do reaches anyone else until you choose to publish.

So you’re free to try things. Make a change, see exactly what it affected, keep it or undo it — none of it visible to anyone downstream while you work.

You’ll find that history behind Versions in the editor toolbar, sitting right next to Publish.

There’s no Save button, and you don’t need one. Every change you make is written to your draft automatically.

What counts as a change is worth knowing, though. Typing in a property panel doesn’t save anything on its own — your input sits there until you click Update. Until you do, you can close the panel and nothing has changed.

If you make a flurry of quick edits, they’re grouped into a single revision rather than dozens of tiny ones, so your history stays readable.

You’ll see Draft saved when a save goes through.

If a save fails: your changes aren’t lost. The editor keeps the full set of changes and retries shortly, and any new edit you make triggers another attempt straight away. You’ll see Couldn’t save the draft while that’s happening.

Saving keeps your work in the editor. Publishing pushes it to the live model, which is what your workbooks and dashboards read.

Until you publish, your changes are yours alone. The Publish button in the toolbar is your signal: it’s available whenever there’s something waiting to go out.

You choose how publishing happens:

Your choice is remembered in your browser, and new browsers start on manual.

Tip: manual mode is the safe default for shared semantic layers. It lets you make a series of related changes and publish them as one coherent update, rather than pushing half-finished work to everyone editing workbooks downstream.

Publish stays available whenever there’s something to publish — unsaved changes, saved changes newer than what’s live, or a previous publish that failed. If you try to close the tab with changes that haven’t reached the live model, your browser will ask you to confirm.

Next to Publish you’ll see Issues with a count. These are problems the editor has found in your semantic layer, and while any remain unresolved, Publish is greyed out with a warning marker over it.

This is deliberate. Publishing sends your model to everyone using it downstream, so the editor won’t let a known-broken model out.

Hover the greyed-out Publish and it tells you exactly what’s holding it up — for example Resolve 7 semantic-layer validation issues before publishing.

Click Issues to see the list and work through them. Once they’re resolved, Publish becomes available again. Your work is saved throughout — a blocked publish never costs you anything.

Two words that sound alike and mean different things:

Versions are created when:

Worth knowing: named versions and post-publish versions are the ones you can count on getting back. The automatic in-between points are best-effort — older detail is tidied up over time, so a very old intermediate revision may no longer be restorable. If you’re about to make a change you might want to undo, name a version first. It takes a second and it’s the difference between “I can get that back” and “I think I can get that back”.

Open Versions and the Version history panel appears on the right.

Versions are grouped by day, newest first. Each one shows the time it was taken, its revision number, and who made the change — or No contributor for one the editor took by itself. The version you’re working on is badged Current Version, and the very first one is called Initial version.

Open the ⋮ menu on a version. What you’re offered depends on which version it is:

The version you’re working on can’t be compared or restored against itself, so it offers only renaming and removal.

Some versions are named for you. Importing a model from the legacy editor, for example, leaves one version either side of the import so you can see exactly what it changed.

Removing isn’t undoing. Removing a version deletes that restore point from your history. It doesn’t change your model — but it does mean you can no longer go back to that moment.

Compare opens the two versions side by side, with a count of what changed between them — for example 2 changes. Changes are sorted into tabs (Tables, Fields, Joins, Dimensions, Measures, Settings), and each entry names what was affected and how many properties changed.

From here you can take back everything at once with Restore all from Rev 0, or tick just the changes you want and restore only those. You don’t have to take all of it.

Restoring asks you to confirm first — Restore this version?, telling you the date you’re reverting to. Nothing changes until you click Restore.

Restoring doesn’t publish. Bringing back an earlier version changes your working copy. It reaches your workbooks only when you publish, exactly like any other edit.

Occasionally an older point in your history can’t be rebuilt — the detail behind it has been tidied away.

When that happens the editor tells you instead of guessing. It won’t reconstruct a version it isn’t certain about, because a semantic layer that’s almost right is worse than one that’s honestly unavailable.

Named versions, publish versions and autosaved versions are the ones that stay restorable.

Note: version history is available for semantic layers connected to Astrato. It isn’t available for browser-local layers, which don’t publish either.

If the live model was edited outside the editor — for example in the legacy editor — the editor notices when you open the layer, and pauses automatic publishing rather than quietly overwriting that work.

You’ll be asked whether to import the changed model. If you decline, both states are preserved and automatic publishing stays paused. You can still edit your draft throughout, and a manual Publish remains available as a deliberate overwrite.

If the check can’t complete, the editor says so and offers a retry — an unavailable check isn’t treated as evidence that someone changed something.

Next: View and restore a previous version walks through the panel step by step, and Publish your semantic layer covers publish modes and what to do when a publish fails.