Generate BPMN from a Narrative — Then Walk It Through with the SME

Workflow area: Process Modeling & Mining · Tier: Core · Hands-on time: ~40 minutes

Text-to-process is one of the most seductive AI capabilities in the BA toolkit: paste a paragraph, get a diagram. The danger is exactly that fluency. A generated model carries the visual authority of a finished artifact, and reviewers critique its layout instead of its truth. Narratives are written by people describing the process as they believe it works — the model faithfully diagrams the belief, smooths ambiguity into clean gateways, and fills narrative gaps with plausible steps nobody performs. So the playbook has two halves of equal weight: generation (fast, cheap, repeatable) and validation (a structured walkthrough where an SME confronts every element). The corrections harvested in the walkthrough are not rework — they ARE the analysis, and the correction log is often more valuable than the diagram.

When to use — and when not to

• Use it to get from narrative to strawman fastinterview notes, an SOP section, or a walkthrough transcript become a discussable diagram in one pass, and people critique diagrams far better than they read prose.
• Use it when the repository needs consistent modelsgeneration plus lint yields uniform notation across analysts; hand-drawn models drift in style and rigor.
• Use it for to-be sketchinggenerate variants of a future process cheaply and let stakeholders react to something concrete (feed the winner into pb-26 gap work).
• Skip publishing without the walkthroughan unvalidated generated model in the process repository is pollution with a timestamp; it will be trusted and it will be wrong.
• Skip it when no SME exists to validateif nobody can confirm what really happens, the honest artifact is a draft marked UNVALIDATED, or better, observation first (pb-24's transcript route).
• Skip BPMN maximalismif the audience needs a five-box flow, generating 60 elements of gateway lattice is notation showing off. Model at the altitude the decision needs.

The recipe

1. 1.

   Stage the narrative. Assemble the source text — SOP extract, interview notes, transcript sections — and mark it up: who is speaking, what era it describes, and any sections you already doubt. The model inherits every ambiguity you feed it, so flag known soft spots now.

2. 2.

   Generate the draft with honesty rules. In Signavio's text-to-process, Miro AI, or the free path via Claude + Mermaid:

   Copy

   Convert this process narrative into a BPMN process model
   (Mermaid flowchart syntax, swimlanes by actor).
   
   Rules:
   1. Model ONLY what the narrative states. Where a path is unclear
      or a step's outcome is unstated, insert a node labeled
      "OPEN: [question]" — do NOT invent connective steps.
   2. Every gateway gets a question label ("Approved?") and ALL
      exits labeled — no unlabeled branches.
   3. Keep exception and rework paths separate; never merge two
      different failure paths into one for tidiness.
   4. Every lane is a named actor/system from the narrative.
   5. After the diagram, list: ASSUMPTIONS you had to make, and
      AMBIGUITIES in the narrative worth asking about.
   
   Narrative:
   [PASTE]
   

3. 3.

   Lint before the SME sees it. Run a second pass — "review this BPMN draft for model-quality defects: unlabeled gateways, missing end events, paths that cannot complete, lanes with no actor, merged exception paths" — and fix mechanical defects yourself. Good draft output looks like this:

   Copy

   flowchart: intake --> completeness{Docs complete?}
   completeness -- yes --> assess[Assessor reviews claim]
   completeness -- no --> OPEN1[OPEN: narrative doesn't say who
   chases missing docs or how often]
   assess --> decision{Approve / Reject / Refer?}
   
   ASSUMPTIONS: treated "senior review" and "referral" as the same
   step (narrative uses both terms).
   AMBIGUITIES: rejection path — can the claimant resubmit?
   

   An honest draft arrives wearing its OPEN flags; a draft with no OPENs from a messy narrative means the model invented — regenerate with the rules tightened.

4. 4.

   Run the SME walkthrough — the step that is not optional. Book 45 minutes with someone who works the process (not who manages it). Script: first walk the happy path end to end — "is this what actually happens, in this order, by these people?" Then interrogate every gateway: "what really happens here? how often does each branch fire? what happens that this diagram doesn't show?" Then every OPEN flag. Log each correction verbatim: what the model showed, what reality is, who said so. Expect merged exception paths, an invented step, and a missing rework loop — the classic trio.

5. 5.

   Correct, stamp, and file the log. Apply corrections, re-lint, and have the SME confirm the corrected model. Publish with a validation stamp — validated-by, date, source narrative version — and file the correction log alongside. The log entries are elicitation findings: several will become requirements, and at least one usually reveals a workaround management didn't know existed.

Make it yours

• SAP Signavio text-to-process: native generation into a governed repository with modeling-convention checks — strongest where the org already runs Signavio; the walkthrough discipline remains yours, not the tool's.
• Miro AI for workshop-native modeling: generate the draft live in the workshop and let SMEs correct it on the board in real time — the walkthrough and the generation collapse into one session.
• Mermaid/draw.io as the free path: Claude-to-Mermaid costs nothing and diffs cleanly in version control; paste into draw.io when stakeholders need BPMN polish.
• Recording-first variant: when the narrative itself is suspect, build the actor-step-system table from transcripts first (pb-24), and generate the model from the table — one less layer of belief between reality and diagram.

Quality check

• The walkthrough happened with a doersomeone who performs the process confronted every gateway and OPEN flag; a manager's nod is not validation.
• The correction log exists and is specificmodel-said / reality-is / who-said-so per correction; an empty log after a walkthrough means the walkthrough was a demo.
• No OPEN flag was silently resolvedevery flag was answered by the SME, converted to a documented assumption, or remains visibly OPEN in the published model.
• Exception and rework paths survivedcount them against the SME's account; merged failure paths and missing rework loops are the signature generation defects.
• The lint is cleanlabeled gateways, complete paths, real end events, named lanes; mechanical quality is table stakes before the model enters the repository.
• The published model carries its stampvalidated-by, date, and source-narrative version; an unstamped process model is a rumor in notation.