START HERE
What you will learn
- Explain what must persist between conversations and devices.
- Separate contribution, review, publication and infrastructure authority.
- Design an update journey usable by a non-developer without bypassing release controls.
Before you start: A working website, versioned source or content, a staging path and named publication owners. The proposed workflow needs implementation; an AI chat alone does not provide it.
Reference edition: Fictional website walkthrough; providers are examples, not required services. Sources checked 2026-11-13.
Persistence belongs to the project, not a conversation
Save the approved brief, brand rules, content model, architecture decisions, repository instructions, check commands and current release references in controlled project storage. Keep requests and their outcomes in durable records with task IDs. An assistant can read this context when authorised; its chat history is not the authoritative state.
A new session must confirm the latest approved source revision and current task status before editing. It should not apply an old plan to an unknown working copy. Store secrets elsewhere, refer to approved profiles rather than embedding credentials, and keep a change history for the project instructions themselves.
Anyone authorised can contribute; not everyone can release
A business owner may propose copy, a stakeholder may review claims, an editor may maintain articles and a maintainer may approve technical or production changes. Small organisations can combine roles while keeping the actions distinct. Give each person a named account and the permissions needed for their role.
Provide a suitable entry point: a CMS, repository-backed editor, change-request form or authenticated dashboard. An assistant can help turn a request into a bounded change, but it should not accept a public prompt as authority to deploy. Use strong authentication, approved devices or access policy where required, and revoke access when responsibilities change.
Turn an ordinary request into a reviewable change
A useful request says what should change, why, where it appears and how to recognise success. The workflow loads the current content and rules, validates the proposed scope and creates a revision or branch. It records the author and preserves the original request without exposing unnecessary personal data.
Checks can catch broken links, missing fields, invalid content and relevant code regressions. An assistant may suggest edits or implement an approved task, but the publisher still enforces permissions and the exact release candidate. A content-only change and a dependency or infrastructure change should not silently receive the same authority.
Use staging as the shared review surface
Send the reviewer a link tied to an identifiable candidate and a concise change summary. They should be able to see the modified content, test the relevant journey and accept or reject the proposal without opening a terminal. A preview link needs access controls when the material is private; a noindex instruction is not authentication.
Record approval against the candidate revision. If another edit lands first, detect the changed base, reconcile conflicts and repeat the relevant checks. A stale approval must not publish a different revision. Serialise releases to each environment and make it clear when a request is waiting, blocked, in review or live.
Remote working does not require public administration
Contributors can use an authenticated browser from an approved location while a controlled build and deployment system handles server access. The CI runner or managed release service needs its own approved route to the host; contributors do not each need an SSH key or email-provider credential.
For low-bandwidth work, favour concise requests, small diffs, build summaries and links to targeted previews. If the connection drops, the durable record should show whether the change was queued, built or published. Resuming the request should reconcile that state, not blindly submit a second release.
Make rollback and handover ordinary tasks
After release, show the public version, check results and previous working reference. Keep a process for restoring a known release and for correcting content that has legal or factual consequences. Remember that rolling back a page does not recall an email already sent or reverse every backend change.
Rehearse the workflow with someone who did not create it. Ask them to propose an edit, find the preview, identify the approver and verify the live result. If they need a private chat, personal token or undocumented laptop command, record and fix that dependency. Review access, recovery instructions and project rules as the business changes.
Technical examples
A request a stakeholder could submit from a browser
This request could enter an authenticated editor, dashboard or assistant. It carries intent and acceptance criteria, not deployment authority.
Change: Clarify the response-time wording on the contact page.
Reason: The current wording can be read as a guaranteed deadline.
Approved replacement: [owner-approved text].
Scope: Contact-page copy only; do not change form routing or email templates.
Check: The new wording appears on mobile and desktop, links still work and the form behaviour is unchanged.
Review: Send the staging candidate to the content owner.
Release: Use the existing production approval process and record the live revision.Roles without shared administrator credentials
| Role | Typical action | Boundary |
|---|---|---|
| Contributor | Propose a content or feature change | No production secret access |
| Content reviewer | Check facts, tone and brand alignment | Approval bound to the reviewed candidate |
| Maintainer | Review code, dependencies and infrastructure implications | Scoped technical authority |
| Release system | Publish an authorised candidate | Environment-specific identity and checks |
| Business owner | Own account recovery and publication responsibility | Durable ownership and access review |
Step-by-step process
Save the project’s operating context
Keep the brief, design rules, content structure, checks and release runbook together under access control.
Choose a contribution interface
Provide an editor, dashboard or repository workflow appropriate to the people making updates. Configure identity and roles.
Normalise and scope the request
Capture the intended change and acceptance criteria, then resolve the latest approved revision and permitted actions.
Create and check a candidate
Generate a diff or content revision, run appropriate checks and make a staging preview available to authorised reviewers.
Bind approval to the actual release
Detect concurrent changes and stale approvals. Publish only the reviewed candidate through the configured release gate.
Report and recover by reference
Show the live revision, evidence and rollback reference. Reconcile interrupted requests before restarting them.
FOLLOW ONE EXAMPLE
Worked scenario
An owner starts an edit on a phone and reviews it later elsewhere
In this fictional example, an authorised owner submits a small wording change through an authenticated dashboard while away from their usual computer.
- The request records approved replacement text and excludes form-routing changes. The system resolves the current source revision.
- A worker or editor produces a candidate and the release pipeline creates a restricted staging preview. The owner loses connectivity before opening it.
- Later, the owner signs in on another approved device and finds the same request, candidate and checks. No personal chat memory is needed.
- If the source has changed, the system reconciles the candidate and requests review again as necessary. The approved version is published and its live identifier is recorded.
What this shows: Continuity comes from durable project state and identity, while publication remains controlled. This is a proposed workflow example, not a feature claimed to exist on every site.
The process at a glance
Read Mermaid diagram source
flowchart TD
U[Authorised person on any approved device] --> I[Editor dashboard or assistant]
I --> C[Persistent brief rules and current source]
C --> T[Scoped change request]
T --> B[Candidate and automated checks]
B --> S[Restricted staging preview]
S --> R[Human review of exact revision]
R --> G{Release gate satisfied}
G -->|No| T
G -->|Yes| P[Production release]
P --> L[Live version and recovery record]
L --> CWhat you should have at the end
- A durable update path usable across authorised people and devices.
- A clear separation between contribution, technical review and production publication.
Common mistakes and how to avoid them
Relying on the last chat as the project specification
Store current approved rules and state where authorised people and tools can retrieve them.
Interpreting anywhere as unauthenticated access
Keep identity, role and device policies in place. Remote convenience does not require open server administration.
Publishing with a stale approval
Tie approval to a revision and re-check when the base or candidate changes.
Promising self-service without an interface
Implement and rehearse the editor or dashboard journey; a repository plus an AI subscription does not automatically provide it.
APPLY THE IDEA
Try it yourself
Your task: Ask someone new to the project to complete a safe wording-change rehearsal without receiving a deployment key.
What to produce: A request, reviewed staging candidate, release record and a list of undocumented dependencies found.
Check your understanding: Can they resume on another approved device and distinguish queued, blocked, reviewed and live states?
Key terms in plain English
- Persistent workflow
- A process whose context, state and evidence survive individual sessions.
- Role-based access
- Permissions assigned according to the actions a person is authorised to perform.
- Stale approval
- An approval attached to a version that is no longer the candidate being released.
- Runbook
- A maintained set of instructions for operating and recovering a system.