Content Flow

A content flow maps the lifecycle of a content item — create → draft → review → approve → publish → update → version → archive/delete — plus who may move it between steps and what every audience sees at each one. It is the editorial cousin of the multi-user flow: the actors collaborate ON an artifact, and the artifact itself carries the state.

The key insight: each content item IS a state flow (State Flow). "Draft," "In review," "Published," "Archived" are states; "submit," "approve," "schedule," "roll back" are events; the rules about who may fire which event are the permission matrix (Permission Flow) attached to the machine. Model it that way and impossible situations (editing a published page with no draft copy, deleting content that's mid-review) become visibly impossible.

Where content flows matter

CMS and publishing platforms, documentation and knowledge bases, education (courses, lessons, assessments), marketing sites (campaign pages with legal review), e-commerce catalogs (product copy), app-store/localized release notes — anywhere content outlives the person who wrote it and more than one pair of hands touches it.

What it answers

What states can an item be in, and what event moves it forward, backward, or out?
Who owns each step (see roles below), and what does everyone else see — is a draft visible to other editors? Is "in review" locked?
What does the PUBLIC see during internal churn? (Old version stays live while the new draft cooks — or does editing take the page down? That decision is the whole flow.)
How do updates, versions, rollbacks, translations, and deletions interact with the live item?

Ownership and roles along the lifecycle

Typical mapping (convention — name your own roles in the matrix):

Create/draft — author owns it; visible to author (+ optionally team); freely editable, auto-saved, never lost (Error Flow: losing a draft is the CMS's worst failure).
Review — reviewer owns the decision; author's editing locked or branched; reviewer needs a queue and the author needs status ("waiting on Sam since Tue") — the waiting-state rules from Multi-User Flow apply verbatim.
Approve/publish — approver/admin owns it; publishing may be immediate or scheduled; the author often may NOT publish (the separation is the point in regulated/branded content).
Update — editor owns a NEW draft of a LIVE page: two versions of one item exist at once (live + working copy). Flows that miss this fork force teams to edit production directly.
Version/rollback — every publish snapshots; rollback is publish-a-previous-version, subject to the same approval rules.
Archive/delete — archive (hidden, restorable, links redirect) before delete (gone); deletion of referenced content must warn about the pages that link to it.

Example — article lifecycle

Create Article ──▶ Save Draft (auto-save; author-owned)
   └─ author leaves ──▶ draft persists; "resume draft" surfaced
Submit for Review ──▶ In Review (locked for author;
   │                   reviewer notified + queued)
   ├─ Approve ──▶ Ready to Publish
   │     ├─ Publish now ──▶ PUBLISHED (v1 snapshot)
   │     └─ Schedule ──▶ Scheduled (visible countdown; cancellable)
   │           ├─ time reached ──▶ PUBLISHED
   │           └─ publish job fails ──▶ alert owner + retry;
   │                 page does NOT half-publish
   ├─ Request Changes ──▶ back to Draft, WITH the reviewer's
   │     comments attached ──▶ revise ──▶ Submit (bounded loop;
   │     round 3 escalates to editor-in-chief)
   └─ Reviewer silent 5 days ──▶ reminder ──▶ reassign
PUBLISHED ──▶ Update ──▶ Working Copy (live v1 stays up)
   │            └─ same review loop ──▶ Publish ──▶ v2 (v1 kept)
   ├─ Error found in v2 ──▶ Roll back ──▶ v1 live again (v2 kept
   │     as a version, not destroyed)
   ├─ Localize ──▶ per-locale copies, each with its OWN state
   │     (en published / de in review); source updates flag
   │     translations stale, never auto-overwrite them
   │     (Internationalization & Localization)
   └─ Archive ──▶ unpublished, redirects in place, restorable
         └─ Delete ──▶ warn: "12 pages link here" ──▶ confirm
               (typed title for high-stakes) ──▶ gone

Failure branches to note: silent reviewers, failed scheduled publishes, bounded change-request loops, rollback that preserves the rolled-back version, and delete that warns about inbound links.

Scheduled publishing, rollback, localization — the three branches teams forget

Scheduling decouples approval from release: state = Scheduled, with visible time, cancel/edit rights defined, and a designed failure alert (a silently failed 9 a.m. launch is a business incident). Embargoes and timezone display deserve explicit copy.
Rollback is the content team's undo — cheap, fast, and safer than panic-editing production; it exists only if publishing snapshots versions by default.
Localization multiplies the machine: each locale copy runs its own lifecycle, tied to the source by a "stale when source changes" flag. Map who owns translations and what readers of a stale locale see (old translation + notice beats machine-overwritten text).

Common mistakes

Only two states, edit and live — every save is a publish, every typo fix a production incident.
Review with no "request changes" route (approve-or-limbo).
Updates that unpublish the live page while editing.
Delete without archive, or archive without redirects (link rot as a designed outcome).
No stale-translation mechanism — locales drift silently for years.
Publishing permissions enforced in the CMS UI only (the API publishes anything — see Permission Flow's last checklist item).

Checklist

The lifecycle is drawn as a state machine: named states, named events, no undefined transitions (State Flow).
Role × event matrix: who can submit, approve, publish, roll back, delete (Permission Flow verbs for the rest).
Live version stays live while updates draft; two-version fork designed.
Review loop is bounded, comment-carrying, and reminder/ escalation-backed (Multi-User Flow).
Every publish snapshots; rollback is one action and itself versioned.
Scheduled publish shows its time, is cancellable, and alerts on failure.
Archive precedes delete; deletes warn about inbound references.
Localized copies have independent states + stale flags.
Drafts auto-save and survive crashes, logouts, and role changes.

Sources

Halvorson, K. & Rach, M. (2012). Content Strategy for the Web, 2nd ed. New Riders — content lifecycle, ownership, and governance.
Harel, D. (1987). "Statecharts: a visual formalism for complex systems." Science of Computer Programming, 8(3), 231–274 — the formal model each content item instantiates (via State Flow).
Draft/review/publish workflow structure as implemented across major CMS platforms is industry convention; role names and step order vary by product — labeled as convention, not a cited standard.