Two jobs, in the surfaces people already work in.
Three people. Three jobs. One wrongly accused flow. The same failure, rendered for whoever is holding it — and one where the honest answer is that it was never Flow.
Detect, explain, decide
She owns the recipe. She never asked for 18 fault emails. The incident finds her in #flow-ops-oncall, and the fix is a proposal she can read before anything is saved.
- INC-4821 posts itself with impact, severity, and the failing step
- Plain-language root cause in the thread — no log scrolling
- Proposed change, in business language, not saved
- Flow Builder draws the failed run · dashed proposal · Agentforce panel
- Accept into sandbox as v5 — Production stays on v4
Reproduce, patch, prove
He is on call and does not want a picture. This one can also start without him: a hook on the Price Book change wakes the agent at 6:41 PM, seven hours before 18 renewals are due to run. Take the fallback then and INC-4821 never exists.
- A CDC hook wakes the agent at 6:41 PM — before anything fails
- Blast radius: 3 flows reference the catalog, 1 has no fault path
- MCP pulls the failed run — element-level trace, not a re-run
- A permission gate before anything is written, even to a sandbox
- Red test reproduces priceBookId = null from the real interview
- PR + DevOps Center · Claude never writes to Production
Caught before the send
A campaign manager, not an admin. Her failure is the kind nobody gets paged for: the Spring Launch sequence will run successfully and quietly reach fewer people than she thinks. Monitoring in her language, before the send — not authoring.
- Slack flags what needs a decision before Day 3 runs
- 1,240 people have no SMS consent — today they silently get nothing
- Agentforce proposes a Day 3 consent path, reusing approved content
- The canvas is where she decides — day-grouped stages, live metrics
- Accept writes a v2 draft · Marketing Ops still owns Activate
“Your flow has failed.” It wasn’t the flow.
The enterprise sev-1 that actually lands on someone’s desk: a flow reports failure, the message says unknown error, and hours later the logs show it was a third-party service the whole time. Flow is the spine of the platform, so it takes the blame for everything hanging off it. Two surfaces, one failure — Priya triages it in Slack until the answer is “this is not ours,” and Devin debugs the same 47 faults in a terminal, where the cause actually lives.
- Which flow, which element — then the honest part: cause is below this element
- Trace walks subflow → Apex → callout → 503 from NetSuite
- Stops at level 5, where platform visibility ends today
- Developer side: the cause is in the Apex log, the gap is one grep over the XML
- Three consumers failed on the same credential — that ends the argument
- Canvas only for the shape of the change, reviewed by a human
- No platform event woke him — a human did, and the demo explains why
- FlowExecutionErrorEvent skips record-triggered flows
- The fix Priya approves is what makes the next session start itself
The rule that holds across all four
Chat never writes to Production. The sandbox is where you rehearse. DevOps is what ships. Flow Builder stays in the story as the trust surface — the picture you confirm against — not the only door in.
Nobody draws the first draft. The other half of headless: an automation that does not exist yet, described in a sentence — and a canvas opened only to confirm it before it goes live.
Describe it, then confirm it
A clicks-not-code admin needs an automation that does not exist yet. He describes it in one sentence and opens the canvas for one reason: to see the real flow before go-live. Seven beats, and a human approves every write.
- One sentence in #revops-build — the agent asks rather than assumes
- The Intent Map first, in words, editable before anything is built
- The trust gate — the actual flow, dashed, Save and Activate greyed out
- Accept writes a sandbox draft · Production is pipeline-only
- Replayed against 200 Leads — the run production can't give you
- Dana Kim approves, DevOps Center ships, it becomes reusable
Six steps, and what each proves
The research the demo is built from. Every step carries what happens, Diego's goal, who is in the loop, the principle it proves, and the hypothesis it tests — including the one nobody has validated yet.
- H1, the riskiest assumption: does the trust gate actually earn trust?
- Reviewers: “once a flow is available to show, we gotta show it”
- Why the Slack-to-Production deploy was pulled from an earlier draft
- Grounded in the Slack canvas principles and the ALM research plan
From a sentence to something running
The authoring half of the developer story, written for people who do not write code: describe it, change your mind cheaply, drop into code only where a real calculation is needed, and open the canvas a year later — when six steps have become thirty-four.
- Describe what you want, get a working first draft back
- Change your mind three equally real ways — code, language, or the map
- Drop into Apex only where a genuine calculation lives
- A colleague reviews the diff · it ships switched off
- Branching is a shape, and no list shows a shape — so open the canvas
The same boundary holds when you are creating
An earlier draft let the admin deploy to Production from Slack, inactive by default. It was pulled: deploying inactive is still a production write, and an active record-triggered flow that throws can roll back the triggering transaction org-wide. So chat does what chat is good at — request, review, approve, observe — and the canvas is where a human confirms the shape before go-live.