# Create Mind Maps in Confluence — Free with Mermaid Plus May 2, 2026 · 12 min read [NGPilot](https://ngpilot.com) 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?[​](#why-mind-maps-in-confluence "Direct link to 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[​](#step-by-step-create-your-first-mind-map "Direct link to 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[​](#step-1----install-mermaid-plus-for-confluence "Direct link to Step 1 -- Install Mermaid Plus for Confluence") Head to the [Atlassian Marketplace](https://marketplace.atlassian.com/) 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[​](#step-2----insert-the-mermaid-macro "Direct link to 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[​](#step-3----write-the-mindmap-header "Direct link to 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[​](#step-4----add-branches-and-sub-topics "Direct link to 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[​](#step-5----save-and-publish "Direct link to 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[​](#mermaid-mind-map-syntax-reference "Direct link to 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[​](#node-shapes "Direct link to 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-and-hierarchy "Direct link to 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[​](#icons "Direct link to 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[​](#comments "Direct link to 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[​](#3-copy-paste-mind-map-examples "Direct link to 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[​](#example-1----product-planning-mind-map "Direct link to 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[​](#example-2----meeting-notes-organization-mind-map "Direct link to 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[​](#example-3----technical-architecture-brainstorm "Direct link to 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[​](#tips-for-effective-mind-maps "Direct link to 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[​](#keep-branch-names-short-and-descriptive "Direct link to 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[​](#limit-hierarchy-depth "Direct link to 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[​](#use-visual-hierarchy-intentionally "Direct link to 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[​](#group-related-ideas-together "Direct link to 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[​](#color-and-style-for-emphasis "Direct link to 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[​](#start-with-a-template "Direct link to 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[​](#update-mind-maps-as-projects-evolve "Direct link to 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[​](#common-mistakes-to-avoid "Direct link to 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[​](#related-resources "Direct link to Related Resources") * [Mermaid Plus for Confluence usage guide](/apps/mermaid-plus-for-confluence.md) -- detailed configuration options, theme settings, and all 29 supported diagram types * [Mermaid Syntax Cheat Sheet](/blog/faq-mermaid-syntax-cheat-sheet-confluence.md) -- quick reference for all Mermaid diagram types supported in Confluence, including flowcharts, sequence diagrams, and ER diagrams * [Create Mermaid diagrams in Confluence](/blog/create-mermaid-diagrams-confluence.md) -- broader guide covering flowcharts, class diagrams, Gantt charts, and more * [Excalidraw Plus for Confluence](/apps/excalidraw-plus-for-confluence.md) -- 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. ## 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) 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:** * [confluence](/blog/tags/confluence.md) * [mermaid](/blog/tags/mermaid.md) * [mindmap](/blog/tags/mindmap.md) * [how-to](/blog/tags/how-to.md) * [diagrams](/blog/tags/diagrams.md) * [brainstorming](/blog/tags/brainstorming.md)