Skip to main content

How to Create a Flowchart in Jira — 3 Methods with Copy-Paste Examples

· 6 min read
NGPilot

Jira is where the work happens — but the process behind the work usually lives in someone's head or in a stale Confluence page nobody opens. A flowchart on the Jira issue itself fixes that: bug triage paths, approval chains, and escalation procedures become visual, unambiguous, and impossible to miss.

Jira Cloud gives you two ways to get there, and they serve different needs. This guide walks through both, then gives you three copy-paste Mermaid flowchart examples for the scenarios Jira teams hit most: bug triage, approval workflows, and incident escalation.

Quick answer: Jira has no built-in flowchart on issues. The native whiteboard lets you draw flowchart shapes on a collaborative canvas — great for a one-off sketch, but the drawing lives outside the issue. To put a versioned, always-editable flowchart directly on a Jira issue, install Mermaid Plus Diagrams for Jira, open the panel on any issue, and paste Mermaid flowchart syntax — every example below is copy-paste ready.

Method 1 — Native Whiteboards (Quick Sketches)​

Jira Cloud includes whiteboards: a collaborative canvas where you drag shapes, arrows, and sticky notes. For a flowchart, you place diamond and rectangle shapes manually and connect them.

Good for: a live brainstorm or a one-off sketch during a meeting.

The limitation: a whiteboard is a separate artifact. It is not attached to the issue whose process it describes, nobody stumbles across it while reading the ticket, and six months later nobody updates it — the classic stale-diagram problem. Dragging 15 shapes and aligning arrows by hand is also slow compared to editing a few lines of text.

If your flowchart is a throwaway sketch, a whiteboard is the fastest path. If the flowchart documents the process the issue follows, it belongs on the issue — that's Method 2.

Method 2 — Mermaid Flowcharts on the Issue (Recommended)​

Mermaid Plus Diagrams for Jira adds a diagram panel to every Jira issue. You write the flowchart as Mermaid — plain text — and it renders live on the issue.

Why text beats drawing for process documentation:

  • Editing is trivial — change a line of text, the diagram re-renders. No re-dragging shapes
  • It lives on the issue — anyone opening the ticket sees the flow immediately
  • It versions with the discussion — the process change and the diagram update land together
  • Copy-paste from anywhere — AI assistants, docs, or a teammate's issue: the syntax transfers intact

Example 1 — Bug Triage Decision Tree​

The classic scenario: a bug report arrives, and every triager follows a slightly different path. Put the decision tree on the epic (or on your bug-template issue) so the path is identical for everyone:

flowchart TD
    A[Bug report arrives] --> B{Reproducible?}
    B -- No --> C[Request more info]
    C --> A
    B -- Yes --> D{Blocks release?}
    D -- Yes --> E[Priority: Critical]
    E --> F[Assign to on-call dev]
    D -- No --> G{Affects core flows?}
    G -- Yes --> H[Priority: High]
    G -- No --> I[Priority: Normal]
    H --> J[Schedule for current sprint]
    I --> K[Add to backlog for grooming]
    F --> L[Hotfix branch + immediate fix]

Every triager now follows the same tree, and the diagram sits on the epic where triage is tracked — not in a comment thread three clicks deep.

Example 2 — Approval Workflow with Colored Stages​

Process flows read much better when node colors carry meaning. classDef styles make stages scannable at a glance — here, a content approval chain with pending, in-review, and done states:

flowchart LR
    A[Draft created] --> B{Peer review}
    B -- Changes needed --> C[Revise draft]
    C --> B
    B -- Approved --> D{Legal review}
    D -- Rejected --> C
    D -- Cleared --> E[Publish]
    E --> F[Archive + notify]

    classDef pending fill:#FFF3CD,stroke:#B8860B,color:#000
    classDef review fill:#E7F1FF,stroke:#2B6CB0,color:#000
    classDef done fill:#D4EDDA,stroke:#2F855A,color:#000
    class A,C pending
    class B,D review
    class E,F done

flowchart LR (left-right) suits workflows with few stages; switch to TD when the chain gets long — vertical layouts survive narrow screens better.

Example 3 — Incident Escalation with Subgraphs​

For incident runbooks, subgraph groups the flow into phases. This one shows detection → escalation → resolution for a production incident, ready to paste onto your incident-type issue or a postmortem template:

flowchart TD
    subgraph Detection
        A[Alert fires] --> B{On-call acknowledges\nwithin 5 min?}
        B -- No --> C[Auto-escalate to secondary]
        B -- Yes --> D[Triage the alert]
    end
    subgraph Escalation
        D --> E{Customer impact?}
        C --> E
        E -- Yes --> F[Open incident channel\npage incident commander]
        E -- No --> G[Fix in normal queue]
    end
    subgraph Resolution
        F --> H[Mitigate + communicate]
        H --> I[Postmortem within 48h]
    end

Paste it once onto your incident template issue, and every future incident starts with the current escalation path in view.

Method 3 — Confluence for the Big Picture, Jira for the Point​

When a process needs long-form context — multiple diagrams, tables, revision history — document it in Confluence with Mermaid Plus for Confluence, then attach a single focused flowchart to the Jira epic and link the two. The issue keeps the at-a-glance flow; the space page keeps the depth. This split mirrors how most teams already use the two tools, and it keeps either side from bloating.

Which Method Should You Use?​

NeedUse
One-off sketch in a meetingNative whiteboard
Process doc that lives on the issueMermaid Plus Diagrams for Jira
Deep documentation with many diagramsConfluence page + summary diagram on the epic

For the second row — the one most teams need most of the time — the flow is: install the app, open the panel, paste one of the examples above, done in under a minute.

Flowcharts turn tribal process knowledge into something every teammate can follow. With Mermaid Plus Diagrams for Jira, the flowchart lives on the issue it documents, edits in seconds, and never goes stale. Install it, paste an example, and put your first process on the ticket today.

Related guides