Exit and Return Flow
How operators leave SG-Builder and return — back-to-record path, draft preservation, re-entry.
The Exit and Return Flow is the boundary handling between SG-Builder and the surrounding SG-Admin record context. It covers what happens when the operator clicks back-to-record (or closes the editor tab), how draft state is preserved, and what the operator sees on re-entry. This page is the Reference definition.
What is this for?
Read this page when you want the structural definition of the editor exit and re-entry — what happens to draft state on exit, and how re-entry restores the editing context.
Good use cases
- You are scoping editorial workflows where operators move between the admin and SG-Builder repeatedly.
- You are explaining to a stakeholder how SGEN preserves work-in-progress.
- You hit a "did my changes save?" question and want the model laid out.
What NOT to use this for
- Step-by-step procedures — open the relevant Guide.
- Per-release shipped change — open What's New or Changelog.
- Browser-tab-close edge cases — out of scope.
How this connects to other features
- SG-Builder Overview — parent surface.
- Builder Workspace — workspace that hosts the back-to-record action.
- Publish Changes — the publish action operators sometimes take before exiting.
- SG-Admin Overview — the surface SG-Builder returns to.
Definition
Exit and Return Flow is the boundary handling between an SG-Builder editing session and the surrounding SG-Admin record context. The flow has three phases: exit (operator leaves SG-Builder), preservation (the platform keeps draft state intact), re-entry (operator opens the same record again and continues from where they left off).
The defining property is preservation across exit. Operators do not lose work-in-progress when they leave the editor.
Purpose
The purpose of this page is to define the exit-and-return behavior as a Reference layer. It explains how the platform handles state across the boundary.
Scope
This page covers Exit and Return Flow at the Reference level.
The page covers:
- The exit action (Menu hamburger → back-to-record) and what it does.
- The Backup action (Publish → More Actions) as a named checkpoint before exit.
- Draft state preservation.
- The re-entry experience.
- Per-step procedures — Guides.
- Browser-tab-close edge cases — out of scope.
- Per-release shipped change — What's New or Changelog.
Exit
Back-to-record action
The back-to-record action is housed inside the Menu hamburger dropdown in the editor, alongside Page Settings, Site Settings, and Templates Library. Clicking it returns the operator to the admin record they opened SG-Builder from.
Draft auto-save
The platform maintains draft state automatically as you edit. By the time the operator opens the Menu and clicks back-to-record, the working draft is already preserved.
Backup action
The Publish button's More Actions dropdown includes a Backup option. Using it creates a named restore point before exiting — useful when the operator wants an explicit checkpoint before leaving.
Preservation
Draft state intact
After exit, the draft state stays in the platform. The operator returning to the same record continues from where they left off.
Versioning
Where the plan supports it, the platform retains version history of saved drafts so operators can restore an earlier draft if needed.
Concurrent editor handling
If another operator opens the same record in SG-Builder while a draft is in progress, the platform surfaces the concurrent-editor state to prevent unintended overwrites.
SG-Builder · Exit and return flow
Exit · Preserve · Re-entry
Exit
Menu → back-to-record
Draft maintained automatically. Backup option in Publish → More Actions for named checkpoint.
Preservation
Draft kept intact
Platform retains draft state. Versioning where plan supports it.
Resume editing
Operator opens same record + clicks Edit with SG Builder; draft restored.
Re-entry
Open the same record
The operator opens the same SG-Admin record (Page, Post, Product, Custom Object) that they had been editing.
Click Edit with SG Builder
The Edit with SG Builder action loads the editor with the preserved draft state. The operator continues from where they left off.
Concurrent state surfaces
If another operator made changes (or has the record open concurrently), the re-entering operator sees the state surface so they can decide whether to merge, overwrite, or hold.
Constraints and boundaries
Exit and Return Flow is a Reference area for the editor boundary handling.
Use this Reference for:
- Understanding what happens to work when the operator leaves the editor.
- Confirming the re-entry experience.
- Per-step procedures — Guides.
- Browser-edge cases — out of scope.
- Per-release shipped change — What's New or Changelog.
Public boundary
This page is intentionally public-safe.
Examples
Example 1 — Editor pauses mid-edit, returns later
The editor is composing a long page in SG-Builder. They click back-to-record to handle a different task. Hours later, they open the same page again and click Edit with SG Builder. The draft state restores; they continue.
Example 2 — Operator publishes before exiting
The operator finishes editing, clicks publish, then clicks back-to-record. The published state is live; the editor exit is clean.
Example 3 — Concurrent editor surfaces
Two operators open the same record. The platform surfaces the concurrent-editor state to both so they coordinate rather than overwriting each other.
Documentation guidance
Use this page as the structural definition for the editor exit and re-entry experience.Reading order
Open this page when scoping editorial workflows that span multiple sessions or multiple operators.
Related reading
- SG-Builder Overview — parent surface.
- Builder Workspace — workspace shell.
- Publish Changes — publish action operators sometimes take before exiting.
- SG-Admin Overview — surface SG-Builder returns to.
Vocabulary cross-reference
- Exit is the operator action that leaves the SG-Builder workspace, accessed via the Menu hamburger dropdown.
- Back-to-record is the action inside the Menu dropdown that returns to the admin record context.
- Backup is the named-checkpoint action available in the Publish → More Actions dropdown, used to create an explicit restore point before or instead of exiting.
- Draft preservation is the platform's retention of unpublished editor state across exit.
- Re-entry is opening the same record again and resuming the editing session.
- Concurrent editor is the state where another operator has the same record open.
Maintenance discipline
When exit and return behavior changes across releases (new draft retention rule, new concurrent-editor surface, new re-entry experience), update this Reference and log the change in Changelog.