Skip to main content

39 posts tagged with "diagrams"

View All Tags

Mermaid AI agents in Confluence: RVS, Gliffy, Mermaid Plus

· 10 min read
Quick Answer

Three Marketplace apps now put an AI agent behind Mermaid in Confluence: RVS Mermaid Diagrams & Charts, Gliffy Diagrams, and Mermaid Plus Diagrams & AI Agent for Confluence. All three can turn a sentence into a diagram. They differ in three things that decide long-term value: what the Mermaid source becomes (page text that diffs, or shapes where the code dies), how much the agent can do (generate once, or create-read-update-convert), and which Mermaid engine is behind it (Gliffy lists 9 formats, RVS 12 types, Mermaid Plus runs all 30 Mermaid v12 types on the 12.3 engine — including the 12.x additions no other agent can draw: Wardley maps, event modeling, BPMN shapes, step animation and agent flows).

What you'll learn
  1. Which three apps ship a Mermaid AI agent for Confluence in 2026, and what each actually does
  2. What's new in Mermaid 12.x — and why engine freshness is part of the agent comparison
  3. What happens to the Mermaid source in each app after the AI is done
  4. How this plays out for architecture diagrams specifically
  5. A decision framework — and the pricing picture

For years, "should we use Mermaid in Confluence?" was a question about editors. In 2026 it became a question about agents: every serious diagramming app on the Marketplace now promises that you can ask for a diagram in plain language and get one. Three of them promise it around Mermaid specifically, and they take visibly different approaches.

This guide compares Mermaid Plus Diagrams & AI Agent for Confluence, RVS Softek's Mermaid Diagrams & Charts for Confluence, and Gliffy Diagrams for Confluence — on what their agents are documented to do, what happens to your diagram source afterwards, and which Mermaid engine each one runs. Every competitor claim here comes from the vendor's own listing or documentation.

Mermaid 12.3 in Confluence: five new diagram types

· 13 min read

Mermaid 12.3 is now live in Mermaid Plus Diagrams & AI Agent for Confluence, and with it come five new diagram templates in the app: Wardley strategy maps, event modeling flows, BPMN process shapes, animated step-by-step flows, and agent workflow diagrams. Each one closes a specific documentation gap that used to force teams into a separate drawing tool — or into whiteboard photos nobody could update.

Mermaid Plus for Jira now ships a Rovo AI agent

· 4 min read

Six weeks ago Mermaid Plus for Confluence became an AI-agent app — a Rovo agent and an MCP server that read and edit the diagrams living in your wiki. Since then, the question we kept hearing from Jira teams was the same one: our issues are where the design decisions happen — when does the agent come here?

Now. Mermaid Plus Diagrams & AI Agent for Jira ships the same agent architecture, pointed at the place Jira work actually lives: the issue.

What the agent can do on an issue​

Jira issues accumulate exactly the content diagrams are good at — architecture sketches attached to epics, workflow flowcharts on process tickets, decision trees on design proposals. Until now, drawing one meant opening the panel editor yourself. Three tools change that:

ToolWhat it does
create-diagramAttaches a rendered Mermaid diagram to an issue
get-diagramReads the diagram source and type back
update-diagramReplaces the source in place, keeping your theme and color settings

The agent edits the same issue property your team edits by hand. Nothing is forked into a side store: an agent-written diagram shows up in the issue panel immediately, and the next person who opens the editor sees exactly what the agent wrote.

Two refusal rules do most of the safety work. One diagram per issue — create-diagram refuses when one exists and points at update-diagram, so the agent never stacks duplicates. And no uninvited writes — when there's no diagram to read or update, the agent stops and asks instead of "helpfully" attaching something you didn't ask for. A wrong-issue or wrong-intent write is the one failure this feature must never have.

Three ways to use it​

1. From an issue (already live). Start a Rovo chat on the issue — the key comes from context automatically. The highest-leverage prompt is the one only an issue-aware agent can do: "diagram this issue" — the agent reads the summary and description and drafts the diagram from the work item itself.

2. In agents you build in Rovo Studio. Add the three Mermaid Plus tools to any Rovo Studio agent, next to tools from your other connected apps. An agent that triages incoming bugs and keeps each one's architecture sketch current is a configuration exercise, not an integration project.

3. In any MCP client. Claude Code, Cursor, or anything that speaks MCP can connect to:

https://mcp.atlassian.com/forge/b1190f13-ccbd-4598-b6a6-fd4276d41594

Exposure is admin-controlled per site: external access is off by default, and a site admin flips it on under Apps → Sites → your site → Connected apps → Mermaid Plus → Tools in Atlassian Administration. Users then approve their own connection through an OAuth 2.1 consent screen. (The built-in Rovo agent needs none of this — it's live the moment the app is installed.)

Connecting Claude Code, concretely:

claude mcp add --scope user --transport http mermaid-plus-jira \
https://mcp.atlassian.com/forge/b1190f13-ccbd-4598-b6a6-fd4276d41594

Then start claude, run /mcp, select mermaid-plus-jira → Authenticate, approve the consent screen, and try:

Read the diagram on DEV-123 and update it to cover the new retry path

Over MCP there is no open issue, so you pass the key (DEV-123 from the issue URL) explicitly — the tools refuse to guess, and missing keys come back as an ask-the-user error.

Permissions travel with the person, not the bot​

Every call runs on the invoking user's own Jira token. Reading needs Browse on the issue; changing the diagram needs Edit Issues. That's not a policy statement, it's the architecture: the app has no as-app write fallback in the agent path, so "the agent did it" can never exceed "I did it." Installation, billing, and data residency are unchanged — the agent is a capability of the Forge app already on your site, not a new vendor trust decision.

Naming note​

The app is now Mermaid Plus Diagrams & AI Agent for Jira — the listing name catches up with what it does, matching the Confluence sibling. Same add-on key, same panel, same pricing; existing installs and links are unaffected.

Both apps are live on the Atlassian Marketplace: Mermaid Plus for Jira and Mermaid Plus for Confluence. The full walkthrough — admin setup, Claude Code, Rovo Studio — is in the user guide.

Mermaid Plus is now an MCP server for AI agents

· 5 min read

Mermaid diagrams won because they are text: they diff cleanly, they live in version control, and AI models are good at writing them. The MCP era should have been the moment every AI client learned to draw them. It half-happened — and the half that happened isn't the interesting half.

The Mermaid MCP ecosystem today: renderers, not editors​

Search the MCP registries for "mermaid" and you'll find a handful of community servers. There is no official one — the Mermaid project ships the library, a CLI, and the mermaid.ink rendering service, but no MCP. The community servers are all variations on one pattern: take Mermaid code, launch a headless browser, render a PNG or SVG, hand the image back to the chat. Some are well built. As a category, they make your AI client a screensaver — it can show you a diagram, but the diagram evaporates when the conversation ends, and nothing your team maintains ever changes.

That's the gap. The diagrams worth editing don't live in chat windows. They live in your wiki, embedded in the architecture page someone's onboarding doc links to. An MCP server for Mermaid should be able to find and maintain those.

What we shipped​

Mermaid Plus Diagrams & AI Agent for Confluence now ships a rovo:mcp module — Atlassian's bridge that turns Forge app actions into MCP tools. The same four actions that power the built-in Rovo agent are now exposed as an MCP server:

ToolWhat it does
create-diagramRenders a Mermaid diagram onto a page or blogpost — or creates a new page with it
get-diagramReads back the diagram source and its version
update-diagramReplaces the diagram source with a version-checked write
convert-diagramTurns Mermaid code blocks already on the page into rendered diagrams, in place

These aren't chat decorations. They edit the real macros on the real page: version locking prevents lost updates, an open editor draft is synced instead of clobbered, and every call runs with the invoking user's own Confluence permissions — the client can only see and change what that person could change in the editor.

Three ways to use it​

1. In Confluence chat (already live). The Rovo agent picks up the page you're viewing — "make this diagram clearer" just works. This is the original surface and it's unchanged.

2. In agents you build in Rovo Studio. Create an agent, Add tools → Connected apps, and add the four Mermaid Plus tools — next to tools from any other app that exposes them. A release-notes agent that reads Jira and updates your architecture diagrams in the same conversation is now a configuration exercise, not an integration project.

3. In any MCP client. Claude Code, Cursor, or anything that speaks MCP can connect to:

https://mcp.atlassian.com/forge/0ddaf927-b00c-4186-8b1a-490be0cb7b69

Exposure is admin-controlled per site: external access is off by default, and a site admin flips it on under Apps → Sites → your site → Connected apps → Mermaid Plus → Tools in Atlassian Administration. Without that toggle the endpoint authenticates but shows no tools; with it, users approve their own connection through an OAuth 2.1 consent screen scoped to sites where the app is installed. (The built-in Rovo agent needs none of this — it's live the moment the app is installed.)

Connecting Claude Code, concretely:

# Register the server (--scope user = available in all your projects)
claude mcp add --scope user --transport http mermaid-plus \
https://mcp.atlassian.com/forge/0ddaf927-b00c-4186-8b1a-490be0cb7b69

Then start claude, run /mcp, select mermaid-plus → Authenticate, and approve the consent screen in the browser. claude mcp list flips from ! Needs authentication to ✔ Connected, and your first prompt can be as plain as:

Read the Mermaid diagram on https://your-site.atlassian.net/wiki/spaces/TEAM/pages/123456789/Architecture and suggest a clearer layout

Cursor users: add the same URL as a remote HTTP MCP server — the OAuth flow is identical. The full walkthrough, including the admin setup, lives in the user guide.

One behavioral difference worth knowing​

In Confluence chat, "this page" means the page you're looking at — the context comes for free. Over MCP there is no open page, so you pass the numeric ID from the page URL (…/pages/123456789/Title → 123456789) or a space key. That's not a limitation we chose; it's the honest shape of working outside the wiki. Every one of our tools' errors will tell the client exactly this rather than guessing at a target — a wrong-page write is the one failure this feature must never have.

Why an app, not a standalone MCP server​

A standalone Confluence MCP server would need you to hand a third party an API token with write access to your wiki. Ours rides on the Forge app you already installed: Atlassian hosts it, access goes through Atlassian's own OAuth and permission layer, and admin controls exposure per site. The MCP server is a capability of the app, not another vendor trust decision.

What's next​

The four tools are the floor, not the ceiling — a search tool (find pages by title or space) is the obvious next one, once it can ship without a scope-change disruption for existing installs. If you're building agents on top of Confluence diagrams, we'd like to hear what's missing: the Marketplace listing takes feedback, and so does this blog.

The Real Cost of Migrating Confluence Macros (2026)

· 6 min read

Somewhere in your Confluence right now there are pages that depend on a third-party app to render. A diagram here, a markdown block there, a whiteboard embed somewhere else. The pages are fine. The app is fine. Everything is fine — until it isn't: the vendor retires the app, gets acquired, or your team outgrows it. And then a question almost nobody has asked out loud suddenly matters: what is actually stored on those pages, and what survives?

We just went through this cycle for Mermaid diagram apps — one major vendor just announced the end of life of its Connect-based app in January 2027 — and the experience taught us a lot about the real cost of macro migration. Not the license cost. The content cost. This post is that breakdown; the Mermaid story is the case study at the end.

The anatomy: what a macro actually leaves behind​

Confluence macros are stored inside the page itself. The app renders them live; Confluence only stores a small block describing the macro and its content. When the rendering app disappears, the page keeps the block but nothing draws it anymore. The text, the diagram definition, the table — whatever the app put in storage — is still there.

So content usually survives the app. What dies is the render. And that is the trap: "my pages still exist" feels safe until you open one and the diagram simply is not there anymore.

Whether the surviving data is usable depends entirely on the vendor:

  • Some apps keep the human-readable source (Mermaid syntax, markdown) directly in storage
  • Some wrap it in JSON with revision history
  • Some store only a rendered image and keep the source in a proprietary attachment format
  • Some do all three, depending on the app version that last touched the macro

Every one of those is a different migration project.

Why the cost is always higher than it looks​

Cost 1: the formats. Each vendor's storage format is undocumented and versioned. Reading "what's on the page" is not a query — it is a small reverse-engineering project per app, sometimes per app version. This is the single biggest line item in any macro migration.

Cost 2: the scale is invisible until you measure it. Teams consistently underestimate how many pages depend on an app, because diagrams are scattered — one here in an architecture doc, three there in a runbook. Nobody costs a migration they have not inventoried.

Cost 3: the app ecosystem keeps generating this problem. This is not a rare event. Atlassian ended its own Server product line in 2024, forcing one of the largest app-and-content migrations in the platform's history. Vendors retire or pivot — the Connect-based Mermaid app by Stratus reaches end of life in January 2027, the very case that prompted this post. Free first-party alternatives keep appearing in the same categories. And independent of any retirement, teams switch vendors — which is the same migration with a different trigger. If your team uses Confluence deeply today, the odds that it will face at least one macro migration in the next few years are close to certain.

Cost 4: the manual fallback is real but doesn't scale. Opening every page and recreating content by hand genuinely works — for ten pages. At a hundred, triage paralysis sets in: nobody costs it, nobody schedules it, and the migration quietly becomes "we'll deal with it when it breaks."

Case study: what migrating Mermaid diagrams took​

When the retirement news landed, we built migration support into our Mermaid app — and the economics matched the framework above almost exactly.

Inventory first. A scan reads page storage and counts macros per page. Teams that ran it found diagrams in spaces nobody expected — the invisible-scale problem, confirmed every time.

Four vendors, four formats. We ended up supporting four distinct storage layouts: source in a macro parameter, source in a JSON blob in the macro body, source in a companion code block, and a renderer macro that references all of the above. Four parsers, each a small reverse-engineering project against undocumented formats.

Conversion is text processing; judgment is not. Replacing an old macro with a new rendered diagram at the same position in the page is mechanical. The hard parts were elsewhere: pages that mix several vendors' macros (convert only what you scanned for?), diagrams whose source cannot be extracted (report them honestly, per page, or they vanish without a trace), and the rollback story (in-place conversion plus page history beats any backup script).

The result: a space sweep per source app, a review table before anything is written, and every conversion landing as a normal page version. That combination turned an unbounded, scary project into a bounded checklist.

The general checklist​

Whatever the macro type — diagrams, markdown, tables, whiteboards — the same checklist applies:

  1. Inventory by scanning page storage, not by asking around
  2. Map the formats: where each vendor keeps the source, and whether it is human-readable
  3. Migrate one vendor at a time, with per-page results before anything is written
  4. Convert in place and let page history be the rollback mechanism
  5. Report failures per page — silent skips are how content quietly dies anyway

The teams that skip steps 1 and 2 are the teams whose migration "unexpectedly" takes a quarter.


If the macros you're leaving behind are Mermaid diagrams, you can start today: Mermaid Plus Diagrams & AI Agent for Confluence includes the migration wizard described above — it recognizes macros from Mermaid Chart, Stratus, the Atlassian Labs viewer, weweave and Tech Labs, and converts them in place. The migration guide walks through every step.

If you're switching away from a different macro type — draw.io, Excalidraw, markdown, tables — the checklist above still applies, and the same pipeline (inventory → parse → convert in place) is how we're expanding coverage: Excalidraw is next on the roadmap. Tell us which app you're switching from — the more we know about the formats teams are actually leaving, the faster that list grows.

And if you're mid-decision right now, bring it to the Community discussion — the "we'll migrate as we go" plan needs all the reality checks it can get.

Mermaid 12.2: Self-Coloring Mind Maps in Confluence

· 4 min read

Mermaid 12.2.0 shipped upstream on October 13, and it is live in all three NGPILOT diagram apps: Enhanced Markdown for Confluence, Mermaid Plus Diagrams & AI Agent for Confluence, and Mermaid Plus Diagrams for Jira. It's a small release with one feature you can see from across the room — mind maps that color themselves by hierarchy depth — and a set of quiet fixes that matter more on Confluence than anywhere else, because Confluence pages are where multiple diagrams share one page.

How to Use PlantUML in Confluence Cloud (3 Working Methods)

· 4 min read

Every team that migrated to Confluence Cloud with a wiki full of PlantUML diagrams hits the same wall: the macro they used on Data Center does not exist in Cloud, and there is no native PlantUML support to fall back on. The source text is usually still there, sitting in page storage — it just has nothing to render it.

Quick answer: there are three working methods in Confluence Cloud. Convert PlantUML into an editable Excalidraw whiteboard with an AI agent (best for diagrams you still maintain), render externally and embed an image (fine for frozen history), or write new diagrams in Mermaid (best for everything you have not created yet). This post shows all three.

Excalidraw AI Agent for Confluence (Chat Whiteboard)

· 7 min read

Confluence holds your team's diagrams in two worlds, and the two don't talk to each other.

Text-defined diagrams — Mermaid and friends — are what AI speaks natively. They're source code, so a chat agent can read them, write them, and revise them. We shipped exactly that last week: an AI agent for Mermaid in Confluence.

Whiteboards are the other world. Freeform shapes, hand-drawn lines, arrows you drag where they need to go — the format that's actually intuitive to put in front of people. Every team has one: the architecture board on the team page, the incident flow everyone references, the onboarding map. And AI couldn't touch any of it. Ask a chat agent for a change to a whiteboard and you'd get a text description of a change, and someone still had to open the canvas and do it by hand.

That gap is why whiteboards go stale. Editing shapes one drag at a time is slow enough that nobody does it, and AI — the thing that was supposed to make maintenance cheap — had no way in.

The AI agent in Excalidraw Plus Whiteboards & AI Agent for Confluence closes the gap: the whiteboard stays what it always was — visual, intuitive, for people — but now you can operate it in plain language, from Confluence chat.

Mermaid AI Agent for Confluence: Draw in Chat

· 5 min read

Confluence chat can write your page, summarize the thread, and answer questions about the space. What it couldn't do — until now — is draw. If you asked for "a flowchart of our deployment process," you got a text description of a flowchart, and someone still had to open an editor and build it.

The AI agent in Mermaid Plus Diagrams & AI Agent for Confluence closes that gap: it creates, reads, updates, and converts Mermaid diagrams directly on Confluence pages and blog posts, from chat.

draw.io vs Mermaid in Confluence: Which Fits Your Docs?

· 16 min read
Quick Answer

draw.io supports Mermaid now — so "does draw.io do Mermaid?" is no longer the question. The question is what the source becomes. In Mermaid Plus Diagrams & AI Agent for Confluence, the Mermaid text stays the diagram: page history shows a text diff, an update is one line, and a Rovo agent can create, read, update or convert diagrams from chat. In draw.io, Mermaid is an import step that turns the diagram into native draw.io shapes, so you get full styling and shape-library freedom but the page holds shape data instead of reviewable text. On the AI side the difference is where the processing happens: Mermaid Plus runs on Atlassian Forge with Atlassian's own Rovo agent, so the diagram and the AI both stay inside the Atlassian trust boundary, covered by your existing Atlassian agreement. Text-first docs → Mermaid Plus. Visual-first, icon-heavy or migration-heavy work → draw.io.

What you'll learn
  1. What changed when draw.io added Mermaid support in 2026
  2. Where the two tools genuinely differ, and where they do not
  3. How the AI features compare — canvas generation vs a Rovo agent on the page
  4. Where the diagram and the AI data live, and why that decides it for enterprise teams
  5. A decision framework for Confluence and Jira teams

Every Confluence team ends up choosing a diagram tool, and most start by asking the wrong question: does it support Mermaid? These days, two answers exist. Mermaid Plus Diagrams & AI Agent for Confluence is built around Mermaid — all 30 Mermaid v12 diagram types, a code editor with live preview, one-click templates for every type, and a Rovo AI agent that works on the page. draw.io is the most-installed diagramming app on the Atlassian Marketplace, with deep shape libraries, whiteboarding, and a Mermaid importer added to its editor.

Both are good tools. This guide compares how they behave in Confluence specifically — how a diagram is created, what is stored on the page, what happens when you need to change it six months later, and what it costs.

Mermaid 12: UML Use Case Diagrams in Confluence & Jira

· 6 min read

Mermaid 12 is the biggest release the diagram language has had in years — and as of today it is live in all three NGPILOT diagram apps: Enhanced Markdown for Confluence, Mermaid Plus Diagrams & AI Agent for Confluence, and Mermaid Plus Diagrams for Jira. You get the headline feature immediately: UML use case diagrams, the diagram type Confluence and Jira teams have been asking for since requirements documents moved out of dedicated UML tools.

Markdown to Mind Map in Confluence (No Drawing)

· 4 min read

Meeting notes, project briefs, planning docs — most Confluence pages already start life as a Markdown-ish outline: a title, some headings, bullets underneath. A mind map is just that outline seen from above. This guide shows how to get from the outline you already have to an interactive mind map on the page, without drawing anything and without learning diagram syntax.

Create a Flowchart in Jira (3 Methods)

· 6 min read

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.

Mermaid vs PlantUML vs Graphviz for Confluence

· 7 min read
Quick Answer

Mermaid, PlantUML, and Graphviz are the three most popular text-based diagramming languages. Mermaid is the easiest to learn and covers the widest range (30 diagram types). PlantUML excels at detailed UML with precise notation control. Graphviz is best for technical network and dependency graphs. Most Confluence teams should start with Mermaid and add Graphviz for network diagrams if needed.

What you'll learn
  1. The strengths and weaknesses of each tool
  2. Which diagram types each one supports
  3. How easy each is to learn and use
  4. A practical recommendation for Confluence teams

Text-based diagramming — writing a few lines of code that render into a diagram — is how modern teams keep diagrams in sync with their documentation. No more drawing boxes by hand in Visio, exporting screenshots, and pasting them into Confluence where they go stale. With text-based diagrams, you edit the source and the diagram redraws instantly.

But there are three major text-based diagramming languages, and they are not interchangeable. Each has different strengths, different syntax, and different ideal use cases. This guide compares Mermaid, PlantUML, and Graphviz so you can choose the right one (or combination) for your Confluence team.

Mermaid Diagrams for Jira Sprint Workflows

· 9 min read
Who should read this
  • Scrum masters and eng leads who run standups from Jira
  • Development teams deciding which diagrams to maintain across a sprint
  • Anyone who wants to know which of Mermaid's 30 diagram types are actually useful for agile work
What you'll learn
  1. The four Mermaid diagram types a sprint team actually reaches for
  2. How to embed each one inside a Jira issue, with copy-paste syntax
  3. When a diagram belongs in Jira vs. Confluence
  4. The full 30-type reference for less common needs

Every team that adopts Jira diagrams hits the same moment: you discover Mermaid supports 30 diagram types, you get excited, and then you realize you have no idea which ones to actually use during a sprint. Most of them never get drawn. The diagrams that earn their keep are the ones that make a standup faster, an onboarding doc clearer, or a ticket unambiguous — and those are a small, repeatable subset.

This post is the workflow guide we wish we'd had: the four diagram types a sprint team actually uses, each with a real scenario and copy-paste syntax you can drop straight into a Jira issue. The full 30-type reference follows, so the same page works as both a sprint playbook and a complete catalog.

Whiteboarding Architecture Sessions in Jira & Confluence

· 7 min read
Who should read this
  • Engineering teams that sketch architecture during planning and design reviews
  • Tech leads who want design decisions captured on the ticket, not lost in a photo
  • Anyone comparing freehand whiteboarding vs. text-based (Mermaid) diagramming
What you'll learn
  1. How to run an architecture whiteboarding session that stays attached to the Jira epic
  2. When freehand sketching beats structured diagrams (and vice versa)
  3. Using 229 cloud/UML/networking shape libraries inside Jira
  4. How Excalidraw and Mermaid complement each other

Every architecture review ends the same way: the team sketches a system on a whiteboard, someone takes a blurry phone photo, and the diagram is never seen again. The next sprint a new engineer joins, asks how the system fits together, and the whiteboard gets redrawn from memory — different every time.

The fix is to capture the architecture sketch on the ticket it describes, editable by anyone on the team, versioned with the issue. That's what Excalidraw Diagrams plus Whiteboards for Jira does: it adds a full drawing canvas to every Jira issue, with 229 bundled shape libraries and freehand drawing. The same experience is available in Confluence via Excalidraw plus Whiteboards for Confluence. This guide walks through running an architecture session that produces a saved, shareable diagram.

Best Confluence Apps for Developers (2026)

· 7 min read

Developer teams use Confluence differently than marketing or HR. You document APIs, share architecture diagrams, write runbooks, and collaborate on code reviews. The default Confluence editor works, but it wasn't built for technical documentation.

This guide covers the best Confluence apps for developers in 2026, organized by use case. We built several of these apps at NGPILOT, so we'll be transparent about where our apps fit and where competitors offer better solutions.

Mermaid Sequence Diagrams in Confluence: FAQ & Examples

· 17 min read

Sequence diagrams are one of the most widely used diagram types in software documentation. They show exactly how participants -- users, services, databases, external APIs -- exchange messages over time. For Confluence teams, embedding sequence diagrams directly on wiki pages means architecture docs, API specifications, and incident post-mortems stay in one place instead of scattered across external tools.

Mermaid's text-based syntax makes sequence diagrams fast to write and easy to update, but the syntax has its own set of rules that can trip you up. This FAQ answers the questions Confluence users ask most often about building sequence diagrams with Mermaid, with expanded explanations, working code examples, and copy-paste templates you can drop straight into a Mermaid Plus macro.

Excalidraw vs draw.io for Confluence Whiteboarding

· 13 min read

When teams need to add diagrams to Confluence, two tools come up again and again: Excalidraw and draw.io (also known as diagrams.net). Both are popular Confluence diagram apps on the Atlassian Marketplace, but they take fundamentally different approaches to visual communication — and picking the wrong one wastes time and licensing budget.

The short version: for live whiteboarding, brainstorming, and freeform sketching, Excalidraw wins. For formal, finalized diagrams (UML, network topology, BPMN), draw.io is the better fit. Most teams end up needing both — and the rest of this post is the honest, feature-by-feature comparison so you can make the right call for your workflow.

Who should read this
  • Product/design teams deciding between Excalidraw and draw.io for whiteboarding
  • Eng leads choosing a diagramming tool for architecture sketches and UML
  • Anyone comparing the two for freeform vs structured diagramming

Confluence Graphviz Diagrams: DOT Language FAQ & Examples

· 16 min read

Graphviz has been the backbone of automated graph visualization for over three decades. Originally developed at AT&T Labs, it powers dependency graphs in build systems, call graphs in profilers, and database schemas in ORMs -- anywhere that diagrams need to be generated from structured data rather than drawn by hand. Graphviz Charts for Confluence brings that same engine directly into your Confluence pages, letting you write DOT language descriptions and get polished, auto-laid-out diagrams without leaving your wiki.

Document Microservices in Confluence with Mermaid

· 14 min read

Mermaid is the most popular text-based diagramming language for technical documentation. One line of code generates a flowchart. A few more produce a sequence diagram, ER diagram, or Gantt chart. Teams using Confluence can embed Mermaid diagrams directly on their pages, keeping diagrams alongside the documentation they illustrate.

Who should read this
  • Platform/backend engineers documenting a microservice architecture
  • Tech leads keeping architecture docs in sync with code
  • Anyone who wants a copy-paste Mermaid syntax reference for Confluence

Create Architecture Diagrams in Confluence (3 Ways)

· 14 min read

Architecture diagrams are the backbone of technical documentation. They show how services communicate, where data flows, and which infrastructure components underpin your system. When a new engineer joins your team, the first thing they look for is an architecture diagram. When something breaks in production, the incident response starts at the same diagram.

Yet many teams store their architecture diagrams in external tools -- draw.io, Lucidchart, or even desktop applications -- detached from the documentation where they matter most. Confluence is where your runbooks live, where architecture decision records are written, and where post-mortem discussions happen. Keeping your architecture diagrams inside Confluence eliminates context-switching and ensures diagrams evolve alongside the written documentation they illustrate.

This guide walks through three ways to create architecture diagrams directly in Confluence, using NGPILOT apps designed for different workflows. Every Mermaid example is copy-paste ready, so you can insert it into a Confluence page and see the result immediately.

Create UML Class Diagrams in Confluence — Free with Mermaid

· 16 min read

Class diagrams are the standard way to model object-oriented systems. They show the classes in your codebase, their attributes and methods, and the relationships between them -- inheritance hierarchies, composition, aggregation, and simple associations. Whether you are documenting a domain model, onboarding new engineers onto a codebase, or collaborating on a design before writing a single line of code, a UML class diagram communicates structure faster than paragraphs of prose.

If your team uses Confluence for technical documentation, embedding class diagrams directly on your pages keeps your design docs next to your architecture decisions, runbooks, and sprint planning notes. With Mermaid Plus Diagrams & AI Agent for Confluence, you can write class diagrams in plain text and render them instantly, no external drawing tool required.

Create ER Diagrams in Confluence (Database Schemas)

· 21 min read

An ER diagram (entity-relationship diagram) visualizes a database schema — the tables, columns, primary and foreign keys, and the relationships between them. If your team documents data models, API contracts, or system architecture in Confluence, embedding ER diagrams directly on the page keeps the schema next to the prose instead of stranded in an external tool as a stale screenshot.

Confluence has no built-in ER diagram support, so you add it with a Marketplace app. The approach below uses Mermaid Plus Diagrams & AI Agent for Confluence, which renders ER diagrams from plain text — meaning diagrams version, diff, and search alongside the rest of your documentation.

What you'll learn
  1. How to add an ER diagram to any Confluence page
  2. The full Mermaid erDiagram syntax — entities, attributes, key types, cardinality
  3. Three copy-paste examples (library, e-commerce, SaaS multi-tenant)
  4. Common mistakes and how to fix them

Entity-Relationship (ER) diagrams are the standard way to visualize database schemas. They show the tables in your database, the columns in each table, primary and foreign key constraints, and the relationships between tables -- one-to-one, one-to-many, and many-to-many. Whether you are designing a new database from scratch, documenting an existing schema for onboarding, or collaborating on a data model before writing migration scripts, an ER diagram communicates structure faster than any amount of prose.

How to Create Gantt Charts in Confluence — Mermaid Examples

· 15 min read

Gantt charts are one of the most widely used visual tools in project management. They give teams a clear, time-based view of who is doing what, when tasks start and end, and how dependencies chain together across a project lifecycle. Whether you are planning a software release, coordinating a marketing campaign, or managing a sprint backlog, a Gantt chart turns a flat task list into a timeline your whole team can read at a glance.

Confluence is where many teams already store their project documentation, meeting notes, and decision records. Embedding Gantt charts directly on Confluence pages keeps your project visuals alongside the context your team needs, instead of burying timelines in a separate project management tool that nobody checks. With Mermaid Plus Diagrams & AI Agent for Confluence, you can write Gantt charts using plain text syntax and see them rendered instantly on the page.

Create Mermaid Diagrams on Jira Issues

· 18 min read

Jira issues are where your team tracks bugs, features, and tasks every day. But describing complex processes, API interactions, or system designs in plain text often leads to confusion and misalignment. Mermaid Plus Diagrams for Jira solves this by letting you create and embed Mermaid diagrams directly on any Jira issue, so the visual context lives exactly where the work happens. No external tools, no attached images that go stale, no switching between tabs.

Create Mind Maps in Confluence — Free with Mermaid Plus

· 12 min read

Mind maps are one of the most effective ways to capture ideas, organize thoughts, and brainstorm with a team. Unlike linear notes or bullet lists, mind maps radiate outward from a central topic, making it easy to see relationships between concepts at a glance. If your team already uses Confluence for documentation, meeting notes, and project planning, adding mind maps directly to your Confluence pages keeps brainstorming sessions alongside the rest of your team's knowledge.

In this tutorial, you will learn how to create mind maps in Confluence using Mermaid syntax and the Mermaid Plus Diagrams & AI Agent for Confluence app. Every example is copy-paste ready, so you can drop it straight into a Confluence page and start organizing your ideas immediately.

Sequence Diagrams in Confluence (Mermaid)

· 13 min read

Sequence diagrams are one of the most practical tools in a software team's documentation toolkit. They show how objects, services, or actors interact over time, making them ideal for documenting API flows, authentication processes, microservice choreography, and error-handling logic. If your team uses Confluence for documentation, embedding sequence diagrams directly on your pages keeps architecture docs alongside everything else your team needs.

In this tutorial, you will learn how to create sequence diagrams in Confluence using Mermaid syntax. Every example is copy-paste ready, so you can drop it straight into a Confluence page and see the result immediately. The examples use Mermaid Plus Diagrams & AI Agent for Confluence, which renders the full Mermaid v12 syntax natively in Confluence Cloud — free to try from the Marketplace.

State Diagrams in Confluence (Mermaid Syntax)

· 17 min read

State diagrams (also called state machine diagrams) model how a system transitions between discrete states in response to events. They are essential for documenting order lifecycles, user authentication flows, CI/CD pipelines, IoT device behavior, and any system where the current state determines what happens next. If your team uses Confluence for technical documentation, embedding state diagrams directly on your pages keeps your design decisions alongside runbooks, architecture decision records, and sprint planning notes.

In this tutorial, you will learn how to create state diagrams in Confluence using the Mermaid stateDiagram-v2 syntax. Every example is copy-paste ready, so you can drop it straight into a Confluence page and see the rendered result immediately.

Mermaid vs Excalidraw vs Graphviz for Confluence

· 11 min read

Looking for the best diagram tool for Confluence? Confluence has no built-in diagramming, so every team adds a Marketplace app — but the right choice depends entirely on what you draw and how you prefer to work. This guide compares the three strongest options — Mermaid Plus Diagrams & AI Agent for Confluence, Excalidraw Plus Whiteboards & AI Agent for Confluence, and Graphviz Charts for Confluence — so you can pick the diagram tool that fits your team instead of guessing.

Quick answer

For most Confluence teams, Mermaid Plus is the best diagram tool — it covers the widest range (30 diagram types), is the easiest to learn, and renders text into diagrams that version cleanly with your docs. Pick Excalidraw Plus if you need freehand whiteboarding and wireframes. Pick Graphviz Charts for dense network and dependency graphs. Many teams install more than one.

What you'll learn
  1. Which diagram tool fits each type of Confluence team
  2. The strengths and trade-offs of Mermaid, Excalidraw, and Graphviz
  3. Pricing, hosting, and integration differences
  4. A decision framework so you can choose in under a minute

Create Mermaid diagrams in Confluence: a step-by-step guide

· 5 min read

Mermaid diagrams in Confluence let you create flowcharts, sequence diagrams, and more using simple text syntax. This guide covers Confluence Mermaid setup with Mermaid Plus — live preview, 30 diagram types, and copy-paste examples.

Who should read this
  • Developers adding diagrams to Confluence documentation
  • Teams switching from draw.io to text-based diagrams (see Excalidraw vs draw.io if you're comparing visual tools too)
  • Anyone needing flowcharts, sequence diagrams, or ER diagrams in Confluence
What you'll learn
  1. How to set up Mermaid in Confluence
  2. Creating flowcharts, sequence diagrams, Gantt charts
  3. All 30 supported diagram types with examples
  4. Troubleshooting common issues

Mermaid Apps for Confluence: Plus vs Stratus vs weweave

· 6 min read

Engineering teams need diagrams in Confluence — flowcharts for runbooks, sequence diagrams for API docs, ER models for database schemas, architecture diagrams for design decisions. Writing diagrams as code (text-based syntax) is faster than drag-and-drop for developers. Mermaid is the most popular text-based diagram language.

Several marketplace apps bring Mermaid to Confluence, plus the major visual diagramming tools (draw.io, Gliffy, Lucidchart) also support it. We built Mermaid Plus Diagrams & AI Agent for Confluence to offer 30 diagram types with live preview, one-click templates, and a built-in syntax guide. In this post we compare it against every alternative.

Excalidraw for Confluence: Whiteboards & Drawings

· 6 min read

Excalidraw in Confluence brings hand-drawn style diagrams and whiteboards to your wiki. This guide compares Excalidraw Plus vs draw.io — features, libraries, and which fits your team's needs.

Who should read this
  • Teams needing whiteboards and diagrams in Confluence
  • Users comparing Excalidraw vs draw.io
  • Anyone adding visual collaboration to documentation
What you'll learn
  1. Excalidraw vs draw.io comparison
  2. Setting up Excalidraw in Confluence
  3. Shape libraries and Mermaid integration
  4. Best practices for team collaboration