How to Create Mind Maps in Confluence with Mermaid

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 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.

Why Mind Maps in Confluence?

Teams reach for mind maps whenever they need to explore a topic from multiple angles without getting locked into a rigid structure. Mind maps are particularly useful for:

• Brainstorming sessions where ideas flow freely and you need a visual way to capture and group them
• Project kickoffs that map out goals, stakeholders, deliverables, risks, and timelines in a single view
• Meeting agenda planning where you lay out discussion topics and subtopics before the meeting starts
• Technical architecture discussions that explore different components, data flows, and integration points
• Knowledge base organization where you plan the structure of a documentation space or wiki hierarchy

Confluence is where much of this context already lives: product requirements, sprint plans, retrospective notes, and architecture decision records. Adding rendered mind maps directly on those pages means your brainstorming artifacts stay connected to the decisions and documentation they informed, rather than living in a separate diagramming tool that nobody revisits.

Mermaid's mindmap diagram type produces clean, hierarchical mind maps from a simple indented text format. Combined with Mermaid Plus for Confluence, you get a first-class editing experience right inside the Confluence editor.

Step-by-Step: Create Your First Mind Map

Follow these steps to go from a blank Confluence page to a fully rendered mind map.

Step 1 -- Install Mermaid Plus for Confluence

Head to the Atlassian Marketplace and search for Mermaid Plus for Confluence. Click Get App and follow the installation prompts. Once installed, the Mermaid Plus macro becomes available on every space in your Confluence instance.

If your organization pre-approves apps, check with your Confluence admin first. The app supports both Confluence Cloud and Confluence Data Center.

Step 2 -- Insert the Mermaid Macro

Open any Confluence page in edit mode. Type /mermaid in the editor and select the Mermaid Plus macro from the dropdown. A code editor panel appears where you can write Mermaid syntax.

Step 3 -- Write the mindmap Header

Start every mind map diagram with the mindmap keyword. Then define the root node, which represents the central topic of your mind map:

mindmap
  root((Central Topic))

The root keyword followed by ((Central Topic)) creates a rounded node at the center of the mind map. This is the starting point from which all branches radiate outward.

Step 4 -- Add Branches and Sub-Topics

Indent lines to create branches. Each level of indentation creates a deeper branch in the hierarchy. Use different node shapes to visually distinguish between types of content:

mindmap
  root((Project Alpha))
    Planning
      Requirements
      Timeline
      Budget
    Design
      Wireframes
      Mockups
    Development
      Frontend
      Backend
      Testing

The indentation controls the hierarchy. In this example, "Planning," "Design," and "Development" are first-level branches from the root, while "Requirements," "Timeline," and "Budget" are second-level branches under "Planning."

Step 5 -- Save and Publish

Preview the mind map inside the macro editor to verify it renders correctly. When you are happy with the result, click Save on the macro, then Publish the Confluence page. The mind map is now part of your living documentation.

Mermaid Mind Map Syntax Reference

Here is a quick-reference for the syntax elements specific to Mermaid mind maps. Bookmark this section and come back to it whenever you need a syntax reminder.

Node Shapes

Different node shapes help you visually distinguish between categories, priorities, or types of content in your mind map:

Shape	Syntax	Description
Rounded (default)	(Topic)	Standard rounded rectangle
Circle	((Topic))	Circle shape, often used for the root node
Square	[Topic]	Square or rectangular box
Bang / Explosion	))Topic((	Cloud or explosion shape, useful for highlighting key items
Hexagon	{{Topic}}	Hexagonal shape for special categories

You can mix and match shapes within a single mind map to encode visual meaning:

mindmap
  root((Product Launch))
    [Pre-Launch]
      ((Research))
      ((Strategy))
    [Launch]
      {{Marketing}}
      {{Sales Push}}
    [Post-Launch]
      ))Feedback((
      ))Iteration((

Indentation and Hierarchy

Indentation defines the parent-child relationships in your mind map. Each level of indentation creates a new tier of branches:

• No indent -- the root keyword defines the central node
• 2 spaces -- first-level branches radiating from the root
• 4 spaces -- second-level branches (sub-topics)
• 6 spaces -- third-level branches (details)
• And so on -- deeper nesting is supported but readability suffers beyond four levels

Consistent indentation is critical. Mermaid parses indentation to determine the structure, so mixing tabs and spaces or using inconsistent indent widths will produce unexpected results. Stick to 2-space increments.

Icons

Mermaid mind maps support FontAwesome icons using the fa:fa-icon-name syntax. Place the icon reference before the node text:

mindmap
  root((Project Plan))
    fa:fa-calendar Timeline
      fa:fa-flag Milestone 1
      fa:fa-flag Milestone 2
    fa:fa-users Team
      fa:fa-user Alice
      fa:fa-user Bob
    fa:fa-cog Technical
      fa:fa-code Frontend
      fa:fa-database Backend

Icons add visual cues that make mind maps easier to scan quickly. Use them sparingly for maximum impact -- an icon on every node can be overwhelming.

Comments

Use %% to add comments that are not rendered in the diagram:

%% This is a comment
mindmap
  root((Ideas))
    %% TODO: add more branches
    Branch A

Comments are useful for leaving notes for yourself or your team about planned additions or the reasoning behind a particular structure.

3 Copy-Paste Mind Map Examples

Below are three practical examples you can paste directly into the Mermaid Plus macro in Confluence. Each example demonstrates a different real-world use case.

Example 1 -- Product Planning Mind Map

This mind map organizes the key areas of a product planning session: user research, feature prioritization, design, engineering, and go-to-market strategy. Use it as a template for your next product kickoff.

mindmap
  root((Product Q3 Plan))
    User Research
      Customer Interviews
      Survey Results
      Support Tickets Analysis
      Competitive Analysis
    Feature Prioritization
      Must Have
        User Authentication
        Dashboard Redesign
      Should Have
        Export to PDF
        Dark Mode
      Nice to Have
        Custom Themes
        API Playground
    Design
      Wireframes
      High-Fidelity Mockups
      Usability Testing
    Engineering
      Frontend
        React Migration
        Performance Optimization
      Backend
        API Versioning
        Database Sharding
      Infrastructure
        CI/CD Pipeline
        Monitoring Alerts
    Go-to-Market
      Launch Blog Post
      Email Campaign
      Webinar
      Social Media Plan

This mind map gives product managers, designers, and engineers a shared view of everything that goes into a quarterly plan. Each team can see where their work fits and how it connects to other workstreams.

Example 2 -- Meeting Notes Organization Mind Map

Mind maps are an excellent format for organizing meeting notes by topic. This example shows how to structure notes from a sprint retrospective or team meeting:

mindmap
  root((Sprint Retrospective))
    What Went Well
      Shipped Feature X on Time
      Reduced Bug Backlog by 30 Percent
      Pair Programming Sessions
      Improved Test Coverage
    What Could Improve
      Cross-Team Communication
        Missed Dependency on Team B
        Unclear API Contract Changes
      Estimation Accuracy
        Underestimated Migration Task
        Overestimated Documentation
      Code Review Turnaround
        PRs Waiting Over 48 Hours
        Need More Reviewers
    Action Items
      ((Setup Weekly Sync with Team B))
      ((Implement PR SLA Policy))
      ((Create Estimation Checklist))
      ((Rotate Review Duties))
    Metrics
      Velocity: 42 Points
      Bug Escape Rate: 5 Percent
      Deployment Frequency: 3 Per Week

The bang-shaped nodes ((...)) for action items make them stand out visually, so anyone reviewing the mind map can immediately spot the follow-up tasks. This format is far more scannable than a flat list of bullet points buried in a meeting-notes page.

Example 3 -- Technical Architecture Brainstorm

This mind map maps out the components, data flows, and infrastructure decisions for a microservice architecture. Use it as a starting point for technical design discussions:

mindmap
  root((Microservice Architecture))
    Services
      User Service
        Authentication
        Profile Management
        Preferences
      Order Service
        Cart Management
        Checkout Flow
        Order History
      Payment Service
        Stripe Integration
        Invoice Generation
        Refund Processing
      Notification Service
        Email
        Push Notifications
        SMS
    Data Layer
      PostgreSQL
        Users DB
        Orders DB
      Redis
        Session Cache
        Rate Limiting
      S3
        File Uploads
        Report Exports
    Infrastructure
      Kubernetes
        Auto-Scaling
        Health Checks
      API Gateway
        Rate Limiting
        Authentication Proxy
        Request Routing
      CI/CD
        GitHub Actions
        Docker Registry
        Blue-Green Deployments
    Observability
      Logging
        Structured Logs
        Log Aggregation
      Monitoring
        Prometheus Metrics
        Grafana Dashboards
      Alerting
        PagerDuty Integration
        Slack Notifications
    Security
      OAuth 2.0
      mTLS Between Services
      Secrets Management

This architecture mind map gives the entire engineering team a bird's-eye view of the system. New engineers can use it to understand the big picture before diving into specific services, and senior engineers can use it to identify gaps in the design during review sessions.

Tips for Effective Mind Maps

A well-structured mind map communicates ideas clearly. A poorly structured one creates confusion. Here are practical tips to get the most out of mind maps in Confluence.

Keep Branch Names Short and Descriptive

Each node in a mind map should be a short phrase, not a sentence. Aim for two to five words per node. If you find yourself writing long phrases, consider breaking the concept into a parent node with child nodes. "Customer Onboarding" is a good branch name. "Implement a new customer onboarding flow that includes email verification and profile setup" is not.

Limit Hierarchy Depth

Mind maps work best with three to four levels of depth. Beyond that, the diagram becomes hard to read and the visual hierarchy loses its impact. If you need more than four levels, consider breaking the mind map into multiple diagrams. Create one high-level mind map that links to more detailed mind maps on separate Confluence pages.

Use Visual Hierarchy Intentionally

Mix node shapes to encode meaning. For example, use ((...)) for the root topic, [...] for major categories, (...) for sub-topics, and {{...}} for action items or highlights. Establish a legend on your Confluence page so your team knows what each shape means. Consistency across mind maps helps everyone read them faster.

Group Related Ideas Together

During brainstorming sessions, ideas often come out in a random order. After the initial capture, reorganize the mind map so related ideas share a parent branch. This clustering is where much of the value of mind mapping comes from -- it reveals patterns and connections that are invisible in a flat list.

Color and Style for Emphasis

Mermaid supports styling directives that let you change the color of specific nodes. Use this to highlight priority items or draw attention to blockers:

style root fill:#f9f,stroke:#333,stroke-width:2px

Apply color sparingly. One or two highlighted branches draw attention. Highlighting everything is the same as highlighting nothing.

Start with a Template

Rather than creating mind maps from scratch every time, build a library of templates for recurring scenarios: sprint planning, retrospective notes, product kickoff, technical design review. Store these templates on a Confluence page in your team space so anyone can copy and customize them.

Update Mind Maps as Projects Evolve

One of the biggest advantages of text-based mind maps in Confluence is how easy they are to update. When priorities shift or new ideas emerge, edit the Mermaid code and republish. Unlike image-based mind maps exported from a separate tool, Mermaid mind maps stay current with minimal effort.

Common Mistakes to Avoid

• Inconsistent indentation. Mermaid mind maps rely on indentation to define hierarchy. Mixing tabs and spaces, or using inconsistent indent widths (e.g., 2 spaces on one line and 3 on the next), will break the structure. Configure your editor to use spaces and stick to a consistent 2-space increment.
• Too many top-level branches. A mind map with 15 branches coming off the root becomes unreadable. Aim for 3 to 7 top-level branches. If you have more, group them into categories.
• Overusing icons. Icons are helpful when used selectively. Placing an icon on every node makes the diagram noisy and defeats the purpose of visual emphasis.
• Skipping the root keyword. The root keyword is required for Mermaid mind maps. Omitting it or misspelling it will prevent the diagram from rendering.
• Forgetting to publish after editing. After modifying the Mermaid code in the macro, you must click Save on the macro and then Publish the Confluence page. The diagram will not update for other users until the page is published.

Related Resources

• Mermaid Plus for Confluence usage guide -- detailed configuration options, theme settings, and all 26 supported diagram types
• Mermaid Syntax Cheat Sheet -- quick reference for all Mermaid diagram types supported in Confluence, including flowcharts, sequence diagrams, and ER diagrams
• Create Mermaid diagrams in Confluence -- broader guide covering flowcharts, class diagrams, Gantt charts, and more
• Excalidraw Plus for Confluence -- hand-drawn style diagrams and whiteboarding for freeform brainstorming sessions

Mind maps are a natural fit for Confluence pages where teams already collaborate on ideas and documentation. With Mermaid Plus for Confluence, creating a mind map is as simple as writing indented text in the macro editor. No external tools, no exported images, no version-control headaches. Install Mermaid Plus for Confluence, paste one of the examples above into a page, and start mapping out your next big idea today.