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

September 13, 2026 ·

<!-- -->

6 min read

[NGPilot](https://ngpilot.com)

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](https://marketplace.atlassian.com/apps/2658777397/), open the panel on any issue, and paste Mermaid `flowchart` syntax — every example below is copy-paste ready.

## Method 1 — Native Whiteboards (Quick Sketches)[​](#method-1--native-whiteboards-quick-sketches "Direct link to 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)[​](#method-2--mermaid-flowcharts-on-the-issue-recommended "Direct link to Method 2 — Mermaid Flowcharts on the Issue (Recommended)")

[Mermaid Plus Diagrams for Jira](https://marketplace.atlassian.com/apps/2658777397/) 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[​](#example-1--bug-triage-decision-tree "Direct link to 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[​](#example-2--approval-workflow-with-colored-stages "Direct link to 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[​](#example-3--incident-escalation-with-subgraphs "Direct link to 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[​](#method-3--confluence-for-the-big-picture-jira-for-the-point "Direct link to 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](/blog/create-mermaid-diagrams-confluence.md), 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?[​](#which-method-should-you-use "Direct link to Which Method Should You Use?")

| Need                                  | Use                                           |
| ------------------------------------- | --------------------------------------------- |
| One-off sketch in a meeting           | Native whiteboard                             |
| Process doc that lives on the issue   | Mermaid Plus Diagrams for Jira                |
| Deep documentation with many diagrams | Confluence 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.

## Related Resources[​](#related-resources "Direct link to Related Resources")

* [Create Mermaid diagrams on Jira issues](/blog/how-to-create-mermaid-diagrams-jira.md) -- the complete guide: sequence diagrams, class diagrams, and settings for Jira issues
* [Mermaid Plus Diagrams for Jira](/apps/mermaid-plus-diagrams-for-jira.md) -- full documentation: configuration, themes, and all supported diagram types
* [Jira diagram apps compared](/blog/jira-diagram-apps-comparison.md) -- how Mermaid Plus stacks up against other Jira diagramming options
* [Gantt charts in Confluence](/blog/how-to-create-gantt-charts-confluence.md) -- timeline views for project plans alongside your process flows

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

* [How to Create Mermaid Diagrams in Jira](/blog/how-to-create-mermaid-diagrams-jira.md)
* [Export Jira Issues to Excel or CSV](/blog/export-jira-issues-to-excel.md)
* [Bulk Download Jira Attachments](/blog/bulk-download-jira-attachments.md)
* [How to Migrate Confluence Content](/blog/how-to-migrate-confluence-content.md)
* [How to Add a Block Quote in Confluence](/blog/block-quote-confluence.md)

Explore NGPILOT[Browse Solutions](/solutions.md)[All Apps](/apps.md)[Atlassian Marketplace →](https://marketplace.atlassian.com/vendors/1226848/?utm_source=ngpilot.com\&utm_medium=blog\&utm_campaign=hub-links)

**Tags:**

* [jira](/blog/tags/jira.md)
* [flowchart](/blog/tags/flowchart.md)
* [diagrams](/blog/tags/diagrams.md)
* [mermaid](/blog/tags/mermaid.md)
* [how-to](/blog/tags/how-to.md)
* [whiteboard](/blog/tags/whiteboard.md)