7.1 The End-to-End Map

Parts V and VI described the stages. This part is about what happens when they run together, repeatedly, without you in the middle of every step.

The first thing to establish is which steps are one-off and which are cyclical. Confusing the two is the most common reason automation efforts produce nothing: people automate a step that happens twice a year and leave the step that happens forty times a month.

The twelve steps

Two observations that reorganize the work.

Five of the twelve are cyclical and human, and they are where your time actually goes: strategy, reference upkeep, QA and selection, assembly, and the disclosure check. Steps 4 through 9 are machine work with a human gate on the output.

Publication is the only irreversible step. Everything before it can be re-run, and this asymmetry is the architectural argument for the approval gate in 7.3: put the human check immediately before the one step you cannot undo.

The flow, with decision points

[1 Strategy] ─→ [2 References] ─→ [3 Identity lock]
                                        │
                                        ▼
              ┌───────────── [4 Batch generation] ◄── prompt list (5.2)
              │                     │
              │                     ▼
              │              [5 Post-processing]
              │                     │
              │                     ▼
              │            [6 QA / selection] ──reject──→ [discard or fix queue]
              │                     │ pass
              │                     ▼
              │              ┌──────┴───────┐
              │         still post      video post
              │              │              │
              │              │         [7 Motion]
              │              │              │
              │              │         [8 Voice]
              │              │              │
              │              │         [9 Lip-sync]
              │              │              │
              │              └──────┬───────┘
              │                     ▼
              │              [10 Assembly]
              │                     │
              │                     ▼
              │           [11 Disclosure check] ──fail──→ back to 10
              │                     │ pass
              │                     ▼
              │           [12 Publication]  ← HUMAN GATE HERE
              │                     │
              └─────────────────────┴──→ [analytics] ─→ review slot (2.6)

Three decision points, and what belongs at each.

After QA (step 6): does this frame or clip go forward, to the fix queue, or to discard? Chapter 5.6's four destinations. This is where the rejection rate is measured, and it is the number that governs your batch sizing.

After assembly (step 10): does the piece pass the delivery checklist from 6.7? This is a checklist, not a judgment call, and it should be a fixed list you run every time.

Before publication (step 12): the human gate. One person decides that this goes out. Not a notification, not an auto-approve after a timeout — a decision.

Which steps are one-off

Steps 1, 2 and 3 happen once per identity version, and the temptation to automate them is strongest precisely because they are technically interesting. Resist it in the wrong order.

Identity lock happens perhaps twice a year. A weekend of manual work twice a year is not a bottleneck. Automating training is a project that takes longer than doing it by hand for a year.

References change quarterly at most. A folder structure and a naming convention (5.3) are sufficient automation.

Strategy is human work and no part of it should be automated, including the part where you decide the persona exists.

Which steps are cyclical

Steps 4 through 10 run every production cycle, and they are where automation returns are:

Generation is the highest-volume step. A batch pipeline (5.4) is the first thing to build, because it is the step with the most repetitions and the clearest interface: a prompt list in, frames out.

QA is the step most people try to automate and should not, entirely. A model can pre-filter obvious defects — malformed hands, blank frames, content that violates a platform rule — and that is worth doing. The judgment about whether a frame is on-model and on-canon is the human contribution, and delegating it to a classifier degrades the thing you are selling.

Assembly is the step where templates pay. A saved project with replaceable slots (6.7) removes most of the repetition without removing the decisions.

Publication is automatable up to the gate. Scheduling, cross-posting, caption placement, and analytics collection are all mechanical. What must remain human is the decision.

Time per cycle

The map becomes operational when the durations are attached. Two representative posts, with attention time separated from machine time.

The ratio is the point. A video post costs roughly three to four times the attention of a still post, and the machine time is a smaller share of it than people expect. This is why chapter 6.1's format mix is a throughput decision: deciding to publish more video is deciding to spend more of your attention per post, and attention is the binding constraint (7.1).

Two consequences for planning. A weekly production slot sized for stills will not absorb video without either more time or fewer posts. And a video retry consumes the same attention as a first attempt, which is the practical reason 6.3's three-attempt rule exists.

Where the bottleneck actually forms

Not where people expect. Three candidates, in the order they actually bind:

Attention at QA. A hundred and fifty frames reviewed at thirty seconds each is over an hour, and it is concentrated human judgment. This is usually the real constraint on volume, and the fix is better rejection rates upstream (a better reference layer) rather than a faster reviewer.

Sequence in video. Chapter 6.4's match-cut chain is inherently serial: clip B waits for clip A's QA. Video production therefore parallelizes worse than stills, and the video share of your mix (6.1) is a direct throughput decision.

Cost ceiling. Not time, but the monthly budget at which the pipeline stops. This is chapter 7.5's subject, and it is a hard wall rather than a soft one.

What is rarely the bottleneck: generation speed. Waiting on a batch is cheap and can be overlapped with other work. Operators optimize it because it is measurable, not because it matters.