DEV Community: Yamuno

Best Atlassian Marketplace Apps for Technical Documentation in 2026

Yamuno — Tue, 12 May 2026 10:34:21 +0000

Best Atlassian Marketplace Apps for Technical Documentation in 2026

Confluence out of the box is solid for general team documentation. For technical documentation specifically — API references, runbooks, architecture records, data science notebooks, engineering wikis — it has gaps. The native editor isn't built for developers, math rendering doesn't exist, and moving content in and out requires manual reformatting.

The Marketplace fills most of these gaps. This is a category-by-category look at which apps are worth installing for technical teams, covering markdown support, math/equations, HTML embeds, and attachment management.

Category 1: Markdown Support

The Problem

Developers write in markdown. Confluence doesn't speak markdown natively. This creates a translation tax — content written in a repo, a README, or a docs-as-code workflow has to be manually reformatted when it enters Confluence.

The inverse is also true: documentation written in Confluence can't easily leave it. Export options produce mediocre HTML or PDFs, not clean markdown that can live in a Git repo.

Markdown Renderer for Confluence

Markdown Renderer for Confluence adds a macro to the Confluence editor that renders markdown inline. Paste markdown into the macro body, save the page, and it renders — tables, code blocks, math, task lists, all of it. No conversion step.

This is the right tool when you want to write and maintain markdown directly inside Confluence without migrating your workflow.

Good for: developers who prefer writing in markdown, teams embedding markdown content from other sources, documentation where the source needs to stay readable as plain text.

Markdown Importer & Exporter for Confluence

Markdown Importer for Confluence & Markdown Exporter handles bulk movement of content: import a ZIP of markdown files, a GitHub repository, or a single file — and export Confluence pages back to markdown.

It preserves hierarchy (folder structure becomes page tree), converts internal links, handles frontmatter, and exposes a REST API for CI/CD pipeline integration.

Good for: migrating documentation from GitHub, GitLab, Notion, or any markdown-native source into Confluence; maintaining docs-as-code workflows where Confluence is the published output.

Other options: There are a few other markdown import tools on the Marketplace. Most are Connect-based (externally hosted), which introduces data routing concerns for teams with strict data residency requirements. Markdown Importer is Forge-native — all processing happens inside Atlassian infrastructure.

Category 2: Math and Equations

The Problem

Technical documentation for engineering, data science, and academic teams frequently needs equations. Confluence has no native math rendering. Your options without an app are: screenshots (bad for accessibility and editability), plain text approximations, or external image generators with manual embed.

LaTeX Math for Confluence

LaTeX Math for Confluence adds a Forge-native LaTeX macro that renders equations server-side. Write standard LaTeX syntax, get rendered math on the page — both inline and display (block) modes supported.

\int_{0}^{\infty} e^{-x^2} dx = \frac{\sqrt{\pi}}{2}

The macro handles the full LaTeX math environment: fractions, summations, integrals, matrices, Greek letters, operator names — anything in the standard math mode command set.

Good for: machine learning documentation, engineering specifications, scientific research, academic writing published to Confluence, or any technical content where equations need to be editable (not screenshots).

Other options: MathJax-based browser-side renderers exist on the Marketplace. They work, but rendering happens client-side — which can produce flash-of-unstyled-content issues and inconsistency across exported PDFs. Server-side rendering (Forge) is more reliable for documentation that needs to be exported or printed.

Category 3: Diagrams and Visuals

The Problem

Architecture diagrams, flow charts, and sequence diagrams are core to technical documentation. They need to be editable by team members, not just the original author who exported a PNG from their laptop.

What's Available

draw.io / Diagrams.net for Confluence is the dominant tool here. It's widely used, has good Confluence integration, and supports UML, BPMN, network diagrams, and general flowcharts. It's a Connect app (externally hosted by JGraph), which is worth knowing.

Gliffy is the other major option — similar capabilities, longer history in the Confluence ecosystem. Also Connect-based.

For code-based diagrams (Mermaid, PlantUML, Graphviz), there are several Forge-native apps emerging that let you write diagram definitions as text and render them inline. This fits well with docs-as-code workflows where diagrams should be version-controllable.

Yamuno doesn't currently publish a diagram app. The draw.io and Gliffy integrations are solid choices for general diagram needs.

Category 4: HTML and Code Embeds

The Problem

Some technical documentation needs custom HTML — embedded interactive demos, styled tables that go beyond Confluence's native capabilities, custom callout boxes, or content migrated from an HTML-based documentation system.

Confluence strips raw HTML by default for security reasons. The native editor provides no HTML passthrough.

HTML Macro for Confluence

HTML Macro for Confluence adds a Forge-native macro that renders raw HTML on Confluence pages. Write or paste HTML into the macro body and it renders in-page.

This is useful for:

Interactive embeds — API sandbox widgets, embedded iframes, interactive demos
Custom styled tables — when the native Confluence table editor isn't flexible enough
Migrated content — documentation originally written in HTML that needs to land in Confluence without losing formatting
Custom callout layouts — info boxes, warning panels, or custom visual elements not available natively

Security note: HTML rendering is controlled by Confluence admins. The macro respects Confluence's content security policies — scripts and external resource loading are subject to the same controls as the rest of the instance.

Category 5: Attachment Management

The Problem

Technical documentation accumulates attachments — build artifacts, design files, exported reports, architecture diagrams, release packages. Over time, Confluence spaces fill with orphaned attachments, duplicate files, and files nobody can find because there's no organization layer.

The native Confluence attachment experience is minimal: files attached to pages, a basic list view, no folder structure, no bulk operations.

Advanced Attachment Manager for Confluence

Advanced Attachment Manager for Confluence adds structured attachment management to Confluence pages — folder organization, version tracking, bulk upload/download, and better search across attachments.

Good for: teams that use Confluence pages to distribute files (release packages, build artifacts, design assets), engineering teams running design review or release management in Confluence, documentation spaces where attachments are first-class content.

How to Evaluate Marketplace Apps

Two things worth checking before installing any Marketplace app:

Forge vs Connect

Forge apps run inside Atlassian's infrastructure. Your data never routes through an external server. This matters for teams with data residency requirements, SOC 2 compliance obligations, or strict network policies.

Connect apps (labeled "server" or with an external vendor hosting model) route data through the vendor's servers. This is fine for many teams but is worth understanding upfront — especially for apps that process documentation content.

All Yamuno apps are Forge-native. On any app's Marketplace listing, the hosting model is listed under the app details.

Permissions and Scopes

Check what Confluence and Jira permissions an app requests at install time. A diagram app that requests write access to your entire Confluence space should prompt questions. Most legitimate apps request narrow, sensible scopes — if something seems excessive, read the privacy policy and check the vendor's security documentation.

Summary

Need	App
Write markdown in Confluence	Markdown Renderer for Confluence
Import/export markdown in bulk	Markdown Importer & Exporter for Confluence
LaTeX equations	LaTeX Math for Confluence
Diagrams	draw.io or Gliffy
Raw HTML embeds	HTML Macro for Confluence
Attachment organization	Advanced Attachment Manager for Confluence

All Yamuno apps are available on the Atlassian Marketplace — free to try, Forge-native.

Questions? Reach out via our support portal.

Building a Jira Dashboard That Actually Tells You Something

Yamuno — Thu, 07 May 2026 10:26:51 +0000

Building a Jira Dashboard That Actually Tells You Something

Most Jira dashboards are abandoned within a month of being created. They start with good intentions — someone sets up a few gadgets, shares the link in Slack, and declares victory. Two sprints later, nobody opens it because the numbers don't mean anything or the widgets are always stale.

The problem isn't Jira. It's that dashboards get built around what's easy to surface rather than what decisions they're supposed to support.

This post covers how to think about Jira dashboards, what metrics actually matter, and how to set up charts that a real team will check daily.

What Makes a Dashboard Useless

Before getting into what works, it's worth naming the failure modes. Most bad Jira dashboards share a few characteristics:

Too many widgets. A dashboard with 12 gadgets isn't 4x as useful as one with 3 — it's less useful because nothing stands out. If everything is visible, nothing is.

Wrong time horizon. A sprint burndown chart that resets every two weeks doesn't help you plan the quarter. A velocity trend over one sprint isn't a trend. Match the widget to the time horizon of the question you're asking.

Metrics that measure activity, not outcomes. "Issues created this week" tells you your team is logging tickets. It doesn't tell you whether the project is on track. Issues closed vs committed is a more honest number.

No audience. A dashboard built for standup looks completely different from one built for an exec review. Mixing those purposes produces something that's mediocre for both.

The Metrics That Actually Matter

Here are the five metrics worth tracking for most software teams, and why:

Sprint Burndown

The most immediate signal. Are you on track to complete your sprint commitment? A healthy burndown slopes steadily toward zero. A flat line mid-sprint means work isn't getting closed. A cliff at the end means scope wasn't broken down properly.

Track it per sprint. The shape matters as much as the final number.

Velocity (Rolling Average)

Sprint velocity — story points or issue count completed per sprint — is useful when you look at it over 4–8 sprints. A single sprint's velocity is noise. A rolling average is a planning input.

Watch for velocity swings greater than ±30% — those usually point to estimation drift, unplanned work, or sprint scope changes worth discussing in retrospectives.

Cycle Time

How long does an issue take from "In Progress" to "Done"? Cycle time is one of the most diagnostic metrics in software delivery. High cycle times for small issues usually indicate blockers, review bottlenecks, or unclear acceptance criteria. High variance means your process is inconsistent.

This is the metric most teams skip and then wonder why estimates are always wrong.

Blockers by Assignee

How many blocked issues does each person have? This is a team health metric disguised as a workload metric. If one person has 5 blocked issues and everyone else has zero, that's a structural problem — not an individual one.

Surface this in your standup dashboard so blockers get visibility before they become incidents.

Issues Without Assignees

Work that's been created but not picked up. In a healthy sprint this number should be low. In a backlog it's expected. When it climbs during a sprint, it usually means scope crept in through the side door.

Setting Up Charts with Charts for Jira Dashboard

Charts - Reports and Graphs for Jira Dashboard is a Forge-native gadget that adds a proper charting layer to Jira dashboards. It supports bar charts, line charts, pie charts, and burndown-style visualizations — all configured directly in the dashboard without needing external tools or BI integrations.

Adding a Chart Gadget

Open your Jira dashboard (or create a new one)
Click Add gadget
Search for Charts — select the Charts gadget
Configure the data source: choose your project, board, or a saved JQL filter
Select the chart type
Set your grouping dimension — status, assignee, priority, sprint, label, component
Set the time range
Save

The gadget renders immediately and stays live — data updates automatically as issues change.

Grouping Options Worth Knowing

Group by status gives you a distribution view — how many issues are in each workflow state. Useful for spotting pileups (10 issues in "In Review," 2 in "Done" — something's blocking review).

Group by assignee shows workload distribution. Combine with a filter for a specific sprint and you can see at a glance if load is balanced.

Group by label or component is useful for teams that run mixed-project sprints — you can see how effort is distributed across workstreams.

Group by sprint over multiple sprints gives you the velocity trend you need for planning conversations.

Three Dashboard Layouts for Different Audiences

Standup Dashboard

Audience: the team. Time horizon: current sprint.

Widget	What It Shows
Sprint burndown	Are we on track?
Blocked issues by assignee	What needs unblocking?
Issues in each status	Where is work piling up?
Issues without assignees	What hasn't been picked up?

Keep this to 4 widgets maximum. The goal is a 60-second read at 9am.

Exec / Stakeholder Dashboard

Audience: non-engineering leadership. Time horizon: current quarter.

Widget	What It Shows
Velocity trend (rolling 6 sprints)	Is the team's throughput stable?
Epic progress (% complete)	Are we hitting roadmap milestones?
Issues by priority (open)	What's the risk surface?
Releases completed this quarter	Shipping cadence

Avoid sprint-level detail here. Execs want quarter-level signal, not sprint noise.

Retrospective Dashboard

Audience: the team. Time horizon: completed sprint.

Widget	What It Shows
Sprint burndown (completed sprint)	Did we hit the commitment?
Cycle time distribution	Were estimates accurate?
Unresolved issues carried over	What spilled?
Velocity vs previous sprint	Did throughput improve?

This dashboard exists to feed the retro conversation, not to survive past it. Create it, run the retro, archive it.

A Note on JQL Filters

Every chart in Charts for Jira is backed by a JQL filter. Learning a few patterns makes dashboard configuration much faster:

-- Current sprint, this project
project = MYPROJ AND sprint in openSprints()

-- Blocked issues
project = MYPROJ AND status = "Blocked"

-- Issues completed in last 30 days
project = MYPROJ AND status = Done AND resolutiondate >= -30d

-- High priority, unassigned
project = MYPROJ AND priority = High AND assignee is EMPTY

Save your most-used filters in Jira's filter management — then reference them by name when configuring gadgets rather than re-entering JQL each time.

Getting Started

Install Charts - Reports and Graphs for Jira Dashboard from the Atlassian Marketplace. It's Forge-native and works on Jira Cloud.

Full documentation is at /docs/charts-for-jira-dashboard.

Questions? Reach out via our support portal.

Docs as Code: How to Export Confluence to Git-Ready Markdown

Yamuno — Sun, 03 May 2026 09:23:26 +0000

Docs as Code: How to Export Confluence to Git-Ready Markdown

Docs-as-code treats documentation like source code: written in plain text, versioned in Git, reviewed in pull requests, and deployed through a CI/CD pipeline. The format is almost always Markdown.

Confluence doesn't fit this model natively. Its export produces HTML or PDF — neither of which belongs in a Git repository. But for many teams, Confluence is where the documentation actually gets written and reviewed. Replacing it isn't always an option.

The practical solution: use Confluence as the editing surface and Git as the source of truth. Export Confluence to Markdown on a cadence, commit the output, and let your pipeline handle the rest.

Markdown Exporter for Confluence is built for exactly this workflow.

What You Need

Confluence Cloud (the app requires Forge and runs on Cloud only)
Markdown Exporter for Confluence installed on your Confluence instance
A Git repository with a docs/ folder (or equivalent)
Optionally: a static site generator like MkDocs or Docusaurus

Step 1 — Structure Your Confluence Space for Export

The exporter preserves your Confluence page hierarchy as a folder structure. If your pages are organised logically in Confluence, the output will be organised logically on disk.

A Confluence structure like this:

Documentation (space root)
├── Getting Started
│   ├── Installation
│   └── Quick Start
├── Architecture
│   ├── Overview
│   └── API Reference
└── Operations
    └── Runbooks

Becomes this folder structure in the exported ZIP:

docs/
├── Getting Started/
│   ├── Installation.md
│   └── Quick Start.md
├── Architecture/
│   ├── Overview.md
│   └── API Reference.md
└── Operations/
    └── Runbooks.md

Most static site generators — MkDocs, Docusaurus, Jekyll, Eleventy — can work directly with this structure.

Step 2 — Configure Filename Patterns

Consistent filenames matter in a Git repo. If file names change between exports, Git treats the old file as deleted and the new one as added — losing commit history.

Markdown Exporter lets you define a filename pattern using tokens:

Token	Value
`{title}`	The Confluence page title
`{date}`	Export date in `YYYY-MM-DD` format
`{id}`	The Confluence page ID

For a stable docs-as-code workflow, use {title} only — so filenames stay consistent across exports as long as page titles don't change. If you need uniqueness guarantees even when titles change, add {id}.

Step 3 — Enable YAML Front Matter

Most static site generators read metadata from YAML front matter at the top of Markdown files. Enable it in the exporter and configure which fields to include:

---
title: API Reference
author: Platform Team
date: 2026-04-23
space: DOCS
confluence_id: "789012"
---

You can also add custom key-value fields — useful for tagging pages with a category, product, or version that your site generator uses to build navigation or filter content.

Step 4 — Export and Commit

Run the export from the Confluence space or page tree you want to publish:

Click ••• → Export to Markdown on the root page, or open from the Apps menu
Set scope to Include Child Pages or Full Space
Enable YAML front matter and set your filename pattern
Click Export and download the ZIP
Extract the ZIP over your docs/ folder in the repository
Commit: git add docs/ && git commit -m "docs: sync from Confluence 2026-04-23"

On the next CI run, your pipeline picks up the updated Markdown and publishes the new docs.

Works With MkDocs and Docusaurus

MkDocs

The exported folder structure maps directly to MkDocs nav. A minimal mkdocs.yml:

site_name: Platform Docs
docs_dir: docs
nav:
  - Getting Started:
    - docs/Getting Started/Installation.md
    - docs/Getting Started/Quick Start.md
  - Architecture:
    - docs/Architecture/Overview.md
    - docs/Architecture/API Reference.md

Or let MkDocs auto-generate nav from the folder structure with the awesome-pages plugin.

Docusaurus

Place the extracted folder under docs/ in your Docusaurus repo. Docusaurus reads YAML front matter natively — the title and date fields will be picked up automatically. Enable autogenerated sidebars and the folder hierarchy becomes the sidebar structure.

Keeping Content in Sync

For a lightweight sync loop:

Export on a schedule — run a full space export weekly, or per-section after each sprint
Review the diff — git diff docs/ shows exactly what changed since the last export
Commit and push — let CI build and deploy the updated site

For more frequent syncs, you can automate around the export step using browser automation or Confluence webhooks that trigger a reminder to re-export. The exporter itself is UI-driven and doesn't currently expose a REST API — so fully automated pipelines work best when paired with a scheduler that prompts the export step.

What the Export Handles

Text formatting — headings, bold, italic, strikethrough, inline code
Tables — column alignment and header rows preserved
Code blocks — fenced with language tag for syntax highlighting
Lists — ordered, unordered, nested, task lists
Images and attachments — downloaded and referenced with relative paths
Internal links — converted to relative Markdown links between files
Info / note panels — converted to blockquotes

Getting Started

Install Markdown Exporter for Confluence free from the Atlassian Marketplace.

Full documentation at /docs/markdown-exporter-for-confluence.

Questions or feedback? Reach out via our support portal.

How to Write Markdown in Confluence Without Losing Formatting

Yamuno — Sat, 02 May 2026 09:10:19 +0000

How to Write Markdown in Confluence Without Losing Formatting

If you've ever pasted markdown into a Confluence page, you know what happens: the formatting disappears and you're left with raw asterisks, backticks, and pound signs. Confluence has its own editor — it doesn't interpret markdown syntax natively.

That's a real problem for technical writers and engineers who write in markdown by default. You end up maintaining two versions of everything, or spending time manually reformatting content every time it moves.

Markdown Renderer for Confluence solves this directly: add the macro to a page, write markdown inside it, and it renders live. No conversion, no reformatting, no copy-paste friction.

Why Confluence Doesn't Support Markdown Natively

Confluence uses a proprietary storage format called Confluence Storage Format (XHTML-based). The editor works at that level — not at the markdown level. When you type in the editor, you're generating structured XML under the hood, not markdown.

There's no built-in way to write **bold** and have it render as bold. You'd have to use the editor's toolbar, keyboard shortcuts, or Confluence macros. That workflow doesn't fit teams who live in markdown — documentation-as-code practitioners, developers writing runbooks, or technical writers migrating content from GitHub or Notion.

What Markdown Renderer Does

Markdown Renderer for Confluence is a Forge-native macro that renders markdown inline on a Confluence page. You insert the macro, paste or write your markdown inside it, and the page displays the rendered output — headings, tables, code blocks, math, and all.

The key behaviors:

Live rendering — what you write in the macro body renders as formatted content on save
GFM support — GitHub Flavored Markdown is fully supported, including tables, task lists, and strikethrough
Code blocks with syntax highlighting — fenced code blocks with language identifiers render with proper highlighting
Math support — inline and block LaTeX expressions via $...$ and $$...$$ syntax
No external requests — everything runs inside Confluence via Forge; your content never leaves Atlassian infrastructure

How to Insert the Macro

Open or create a Confluence page
In the editor, type / to open the macro browser
Search for Markdown Renderer
Select it — a macro placeholder appears on the page
Click into the macro body and write or paste your markdown
Save the page

That's it. The macro renders on save, and any editor who opens the page for editing sees the raw markdown in the macro body — editable as plain text.

Markdown Features Supported

Headings and Text

Standard ATX-style headings (#, ##, ###) render as Confluence heading levels. Emphasis (*italic*, **bold**), strikethrough (~~text~~), and inline code (`code`) all work as expected.

Tables

GFM pipe tables render correctly, including column alignment:

| Method | Endpoint         | Auth     |
| ------ | ---------------- | -------- |
| GET    | /api/v1/users    | Required |
| POST   | /api/v1/sessions | None     |

This is particularly useful for API documentation and reference tables — content types that are painful to build in the Confluence native editor.

Code Blocks

Fenced code blocks with language identifiers:

```

python
def parse_webhook(payload: dict) -> Event:
    return Event(
        type=payload["type"],
        data=payload.get("data", {}),
    )


```
```

`

Syntax highlighting is applied automatically based on the language tag.

### Math

If you're writing technical documentation that includes equations, the macro supports LaTeX math syntax:

```markdown
The time complexity is $O(n \log n)$.

$$
\sum_{i=1}^{n} x_i = \frac{n(n+1)}{2}
$$
```

This uses the same rendering pipeline as [LaTeX Math for Confluence](https://marketplace.atlassian.com/apps/1238016/latex-math-for-confluence?hosting=cloud&tab=overview) — equations render cleanly without needing a separate macro for simple cases.

### Task Lists

```markdown
- [x] Write the API spec
- [x] Review with backend team
- [ ] Update the runbook
- [ ] Notify stakeholders
```

These render as visual checkboxes, making them useful for runbooks, checklists, and release notes embedded in Confluence pages.

---

## Practical Tips for Technical Writers

**Keep your source in markdown.** If you're maintaining documentation in a Git repo, the Markdown Renderer macro lets you paste the current content into Confluence without reformatting it. When the source changes, you update the macro body. It's not automated sync (for that, use Markdown Importer's REST API), but it's fast enough for most workflows.

**Use one macro per logical section.** You don't have to put an entire page inside a single macro. Mix native Confluence content with markdown macro blocks — use the native editor for page layouts, comments, or Confluence-specific macros, and drop into the markdown macro for content-heavy sections.

**Watch your frontmatter.** If you paste markdown from a file that has YAML frontmatter (`---` block at the top), strip it before pasting — the renderer will display it as text. Frontmatter is handled at import time by Markdown Importer, not at render time.

**Tables with many columns.** Confluence pages have a fixed width. Very wide markdown tables can overflow the macro boundary. Either reduce the column count or apply a full-width page layout before inserting the macro.

---

## When to Use Markdown Renderer vs Markdown Importer

These are different tools for different problems:

| Scenario | Tool |
| -------- | ---- |
| Write markdown inline on a Confluence page | Markdown Renderer |
| Bring in a file, folder, or GitHub repo as Confluence pages | Markdown Importer |
| Automate doc sync via CI/CD | Markdown Importer (REST API) |
| Live markdown editing in Confluence | Markdown Renderer |

If your workflow is "write in markdown, publish to Confluence," you likely want both.

---

## Getting Started

Install [Markdown Renderer for Confluence](https://marketplace.atlassian.com/apps/1238017/markdown-renderer-for-confluence?hosting=cloud&tab=overview) from the Atlassian Marketplace. It's Forge-native, so no external server connections, no CSP exceptions, and no admin firewall approvals needed.

Full documentation is at [/docs/markdown-renderer-for-confluence](/docs/markdown-renderer-for-confluence).

---

_Questions? Reach out via our [support portal](https://yamuno.atlassian.net/servicedesk/customer/portals)._

Yamuno is a Finalist for Atlassian Partner of the Year 2026: Marketplace Rising Star

Yamuno — Thu, 30 Apr 2026 17:32:49 +0000

Yamuno is a Finalist for Atlassian Partner of the Year 2026: Marketplace Rising Star

We have some exciting news to share: Yamuno has been named a finalist for the Atlassian Partner of the Year 2026: Marketplace Rising Star Award.

This recognition means a great deal to our team. The Atlassian Marketplace is home to thousands of apps, and being recognized as a Marketplace Rising Star is a reflection of the trust that Confluence and Jira users have placed in our products. We don't take that lightly.

What is the Atlassian Partner of the Year 2026: Marketplace Rising Star Award?

The Atlassian Partner Awards are given annually to recognize partners who demonstrate exceptional commitment to customer success, product quality, and growth within the Atlassian ecosystem. The Marketplace Rising Star category specifically honors vendors who have shown outstanding momentum, adoption, and customer impact over the past year.

Being named a finalist means Atlassian has recognized Yamuno among the top performers in this category — and that is something we are genuinely proud of.

Our Journey on the Atlassian Marketplace

Yamuno started with a single mission: build Forge-native apps that teams can actually trust. No external servers. No data leaving Atlassian infrastructure. Just reliable tools that do exactly what they promise.

Over the past year, we've grown our portfolio to eight apps — all built on Atlassian Forge and focused on making Confluence and Jira more powerful for the people who use them every day:

Markdown Importer for Confluence Cloud — import and export markdown files, page trees, and entire spaces with full formatting support
Markdown Exporter for Confluence — export pages to clean, portable Markdown with YAML front matter, Obsidian wikilinks, and custom filename patterns
HTML Macro for Confluence — embed custom HTML, CSS, and JavaScript inside Confluence pages with enterprise CSP controls
LaTeX Math for Confluence — professional LaTeX equation rendering with live preview and access controls
Charts for Jira Dashboard — interactive, customizable charts and tables built directly into your Jira dashboard
Markdown Macro for Confluence — write, preview, and publish rich Markdown content natively in Confluence
Advanced Attachment Manager for Confluence — find, filter, and clean up attachments across your entire Confluence instance
PDF Exporter for Confluence — export pages, hierarchies, or spaces to professionally formatted PDFs with custom templates

Each app was built in response to real pain points we heard from the community — things teams needed but couldn't find a reliable solution for.

This Wouldn't Exist Without You

Recognition like this isn't built in a vacuum. Every review left on the Marketplace, every support ticket that pushed us to make something better, every user who suggested a feature or reported an edge case — that community feedback is what shaped these products into what they are today.

If you've been a Yamuno customer, this nomination belongs to you as much as it does to us. Thank you.

What's Next

We're continuing to build. The same principles that got us here — Forge-native security, focus on real workflows, and responsiveness to user feedback — are what will drive everything we ship next.

Explore our full app portfolio on the Atlassian Marketplace or reach out at support@yamuno.com.

How to Export Confluence to Obsidian (With Wikilinks)

Yamuno — Tue, 28 Apr 2026 10:17:28 +0000

How to Export Confluence to Obsidian (With Wikilinks)

Confluence and Obsidian serve different needs. Confluence is where teams collaborate on documentation. Obsidian is where individuals build a personal knowledge base, connect ideas, and think in networks of linked notes.

If you use both, you've probably felt the friction: Confluence content doesn't transfer cleanly to Obsidian. Copy-pasting loses formatting. Downloading HTML is useless. Internal links between pages become broken references.

Markdown Exporter for Confluence solves this with a dedicated Obsidian mode that converts Confluence page links to [[wikilinks]] automatically.

The Problem With Standard Confluence Export

Confluence's built-in export options are HTML and PDF. Neither works with Obsidian:

HTML — Obsidian doesn't render HTML as notes. You'd need to strip tags manually.
PDF — read-only, not searchable in Obsidian's graph, and not linkable.

Even if you extract text, internal links ([See also: Architecture Overview](/wiki/spaces/PROJ/pages/...) become long URLs that Obsidian doesn't recognise as note links. Your knowledge graph breaks.

What Obsidian Mode Does

When you enable Obsidian mode in Markdown Exporter, every internal Confluence page link is converted to [[Page Title]] format:

Before (standard export):

See the [Architecture Overview](https://yoursite.atlassian.net/wiki/spaces/PROJ/pages/123456/Architecture+Overview) for context.

After (Obsidian mode):

See the [[Architecture Overview]] for context.

Obsidian resolves wikilinks by note title, so as long as the referenced page is in your vault, the link works — and shows up in the graph view.

Step-by-Step: Export Confluence to Obsidian

Step 1 — Install Markdown Exporter

Install Markdown Exporter for Confluence from the Atlassian Marketplace. It requires Confluence Cloud and takes about 30 seconds to install.

Step 2 — Open the Exporter

Navigate to the Confluence page or space you want to export. Click ••• (More actions) → Export to Markdown. For a full space, open it from the Apps menu in global navigation.

Step 3 — Enable Obsidian Mode

In the export options panel, toggle Obsidian Wikilinks on. This switches internal link output from standard Markdown links to [[Page Title]] format.

Step 4 — Configure YAML Front Matter (Optional)

Enable YAML front matter to include metadata at the top of each exported note:

---
title: Architecture Overview
author: Jane Smith
date: 2026-04-23
space: PROJ
confluence_id: "123456"
---

This is useful if you use Obsidian plugins like Dataview to query note properties, or if you want to track which Confluence page each note came from.

Step 5 — Select Scope and Export

Choose your scope:

Single page — exports one .md file
Page tree — exports a parent page and its children as a structured ZIP
Full space — exports everything in the space as a ZIP with folder hierarchy

Use the in-tree search to find specific pages if you only need a subset.

Step 6 — Add to Your Obsidian Vault

Extract the ZIP into a folder inside your Obsidian vault. Obsidian will immediately index the notes. If you enabled wikilinks mode, the internal links between pages will resolve — and they'll appear in the graph view.

What the Export Preserves

Content Type	Obsidian Output
Headings	`#`, `##`, `###`
Bold / Italic	`bold`, `italic`
Tables	Standard Markdown tables
Code blocks	Fenced with language tag
Lists	Ordered and unordered
Images & attachments	Downloaded, referenced with relative paths
Internal page links	`[[Page Title]]` wikilinks
External links	Standard `[text](url)`
Info / warning panels	Blockquotes

Tips for Obsidian Users

Use a dedicated folder. Keep your Confluence imports in a subfolder like confluence/ so they don't mix with your personal notes. You can still link across folders.

Sync regularly with a script. If your team's Confluence content changes often, set up a regular export and overwrite the vault folder. Links won't break as long as page titles stay the same.

Combine with Dataview. If you include YAML front matter, you can build Dataview queries over your Confluence notes — e.g. all pages in a specific space, or notes modified after a certain date.

Check complex macros. Most Confluence content converts cleanly. Heavily customised layouts or third-party macros may need a quick review after export.

Getting Started

Install Markdown Exporter for Confluence free from the Atlassian Marketplace.

Full documentation is at /docs/markdown-exporter-for-confluence.

Questions? Reach out via our support portal.

5 Ways to Clean Up Confluence Storage Without Breaking Anything

Yamuno — Fri, 24 Apr 2026 09:47:34 +0000

5 Ways to Clean Up Confluence Storage Without Breaking Anything

Confluence storage has a way of quietly filling up. Old attachments accumulate, duplicate files get uploaded, outdated page versions pile up — and suddenly your admins are getting storage warnings.

The tricky part is cleaning it up safely. Delete the wrong file and you break a page that someone still relies on. Here are five practical approaches to reclaim storage without causing collateral damage.

1. Audit Attachments Before You Delete Anything

The first mistake most admins make is deleting files before understanding what's actually taking up space. Start with an audit.

Advanced Attachment Manager for Confluence gives you a searchable, filterable view of every attachment across your entire Confluence instance — sorted by file size, type, space, or date. You can instantly see:

Which spaces are consuming the most storage
Which file types are taking up the most space (PDFs? Videos? Zip files?)
Which attachments are oldest and most likely outdated
Which pages have the most attachments

This takes the guesswork out of cleanup. You know exactly what to target before you touch anything.

2. Delete Old Attachment Versions

Every time someone re-uploads a file with the same name, Confluence keeps the previous version. Over time, old attachment versions accumulate invisibly — they don't show up in search but they count against your storage quota.

To clean up attachment versions:

In standard Confluence: go to a page → Attachments → select an attachment → view history → delete old versions
With Advanced Attachment Manager: identify pages with many attachment versions across the whole instance and bulk-delete old versions in one operation

This is often one of the biggest wins in a storage cleanup — old file versions can account for a surprising percentage of total usage.

3. Find and Remove Duplicate Files

Teams frequently upload the same file multiple times — the same logo across ten different spaces, the same template ZIP uploaded by multiple people, the same diagram in slightly different versions.

To find duplicates:

Use Advanced Attachment Manager's filter by file type and size to spot files of identical size
Search by filename to find the same file uploaded across multiple spaces
Consolidate duplicates — keep one canonical version, update page references, delete the rest

For images specifically, bulk-replacing references and consolidating to a single version can reclaim significant space.

4. Clean Up Orphaned Attachments

Orphaned attachments are files that were uploaded to a page and then the page content changed — the file is still there but no longer referenced in the page body. It shows in the attachments list but isn't embedded anywhere.

These are almost always safe to delete, but confirming manually across thousands of pages is impractical. Advanced Attachment Manager lets you filter for unreferenced attachments and review them in bulk — so you can clean them up with confidence rather than blindly deleting.

5. Archive Old Spaces Instead of Letting Them Rot

One of the biggest contributors to storage bloat is spaces that are no longer active but never archived or cleaned up. Old project spaces, deprecated product docs, completed initiative wikis — they accumulate attachments and page versions indefinitely.

The right approach:

Identify inactive spaces — no edits in the last 6–12 months
Export the space to markdown or PDF if you want a permanent record (Markdown Exporter handles this)
Archive the space in Confluence — it becomes read-only and stops accumulating versions
Delete the space if you're confident nothing in it is needed

Archiving before deleting gives you a safety net. Export first if there's any doubt.

Bulk Actions Save Hours

The reason storage cleanups get neglected is that the manual process is slow. Click into each page, open attachments, check each file, decide, delete. Multiply that by thousands of pages and it becomes a multi-day project.

Advanced Attachment Manager's bulk actions let you:

Select multiple attachments across pages and spaces
Delete, move, or download them in one operation
Filter by type, size, date, or space to scope your cleanup precisely

What would take days manually takes an hour with the right tooling.

Before You Delete Anything

A few rules of thumb:

Check if the file is referenced in a page body. Deleting an attachment that's embedded in a page will break the embed. Advanced Attachment Manager shows you where each attachment is used.

Start with the obvious. Target large files first — videos, zips, PDFs. A single 500MB video file does more damage to your quota than a thousand small images.

Use spaces to scope your cleanup. Don't try to clean the entire instance at once. Pick one or two high-storage spaces and clean those first.

Don't delete page versions from active pages. Version history is there for a reason. Focus on old attachment versions, not page versions.

Getting Started

Advanced Attachment Manager for Confluence is available on the Atlassian Marketplace.

Full documentation at /docs/advanced-attachment-manager.

Questions? Reach out via our support portal.

Export Confluence Pages to Polished PDFs — Introducing PDF Exporter for Confluence

Yamuno — Thu, 23 Apr 2026 14:04:25 +0000

Introducing PDF Exporter for Confluence

We're excited to announce that PDF Exporter for Confluence is now live on the Atlassian Marketplace.

Confluence's built-in PDF export is minimal — no cover page, no custom headers, no watermarks, and certainly no reusable templates. For teams sharing documentation with clients, stakeholders, or regulators, "minimal" doesn't cut it.

PDF Exporter fills that gap.

What Is PDF Exporter for Confluence?

PDF Exporter is a Forge-native Confluence Cloud app that lets you export any page, page hierarchy, or entire space to a professionally formatted PDF — without leaving Confluence and without sending your data anywhere outside Atlassian's infrastructure.

Key Features

Single Page, Hierarchy, or Full Space

Export exactly what you need:

Single page — export any Confluence page to PDF in one click
Page tree — select a parent page and include all child pages in one export
Full space — export an entire Confluence space as a packaged ZIP of PDFs

Multi-page exports are automatically bundled into a ZIP download.

Reusable Templates

Admins can define export templates from Confluence Settings → PDF Exporter. Each template controls fonts, layout, cover page style, header and footer content, watermarks, and page numbering.

Once a template is saved, every user on the instance can apply it — no more inconsistent formatting across teams.

Six Cover Page Styles

Choose from six built-in cover page layouts and customise them with your accent color, company logo, author name, and subtitle. Every exported PDF looks like it came from your design team.

Automatic Table of Contents

Enable the TOC option and the exporter automatically generates a clickable table of contents from your page headings — with configurable depth so you control how detailed it gets.

Headers, Footers & Watermarks

Add custom text, page numbers, or a watermark to every page of the exported PDF. Useful for draft reviews, confidential documents, or any output where you need persistent labelling.

Runs Entirely on Atlassian Forge

PDF Exporter is 100% Forge-native. All processing happens inside Atlassian's infrastructure — exported PDFs are delivered directly to your browser and never stored on external servers.

Who Is It For?

PDF Exporter is built for teams that share documentation beyond Confluence:

Technical writers producing release notes, product specs, or user guides for external distribution
Solutions engineers creating polished client-facing proposals or handover documents
Compliance and legal teams archiving Confluence content with consistent formatting and watermarks
Project managers sharing status reports and project documentation with stakeholders who don't have Confluence access

Getting Started

Install the app from the Atlassian Marketplace
Open any Confluence page and click ••• (More actions) → Export to PDF
Choose a template (or use the default)
Select the scope — single page, page tree, or space
Click Export and download your PDF

Admins can create and manage templates from Confluence Settings → PDF Exporter.

👉 Install PDF Exporter for Confluence

👉 Read the Documentation

Questions or feedback? Reach out via our support portal — we'd love to hear how your team is using it.

How to Migrate Your GitHub or GitLab Docs to Confluence (Step-by-Step)

Yamuno — Thu, 23 Apr 2026 13:59:26 +0000

How to Migrate Your GitHub or GitLab Docs to Confluence

Engineering teams often end up with documentation scattered across two places: a docs/ folder in the repo, and a Confluence space that slowly falls behind. This guide shows you how to close that gap — whether you want a one-time migration, a bulk import, or a fully automated sync that keeps Confluence updated on every push.

Why Teams Move Docs to Confluence

Keeping docs in Git is great for developers, but it creates friction for everyone else. Product managers, support teams, and stakeholders usually live in Confluence — not in GitHub. When your README and architecture docs live in a repo, they become invisible to half the company.

At the same time, manually copy-pasting markdown into Confluence is tedious and breaks formatting. The goal is to do this once, correctly, and then keep it in sync automatically.

What You Need

Confluence Cloud (any plan)
Markdown Exporter & Importer for Confluence installed
Your markdown files from GitHub or GitLab (as a ZIP or local clone)

Option 1 — Import a Single File

Best for: migrating a single README, architecture doc, or changelog.

Open the target Confluence page where you want the content to live
Click the ••• (More actions) menu → Markdown Importer & Exporter
Select Import and choose your .md or .mdx file
Preview the output, then click Import

Your markdown — including headers, tables, code blocks, and images — is converted to native Confluence content.

Option 2 — Bulk Import from a ZIP Archive

Best for: migrating an entire docs/ folder from a repo in one shot.

Step 1 — Clone and zip your docs folder

git clone https://github.com/your-org/your-repo.git
cd your-repo
zip -r docs-export.zip docs/

For GitLab, it's the same process — or use the GitLab UI: Repository → Files → docs/ → Download this directory.

Step 2 — Import the ZIP into Confluence

In Confluence, navigate to the space or page where you want the docs imported
Open the ••• menu → Markdown Importer & Exporter
Select Import and upload your docs-export.zip
Review the file tree — the importer shows all files and their resolved hierarchy before importing

Step 3 — Confirm hierarchy

The importer converts your folder structure into a Confluence page tree. A structure like:

docs/
  getting-started/
    installation.md
    quick-start.md
  api/
    overview.md
    authentication.md

…becomes parent/child pages in Confluence exactly as you'd expect — no manual reorganisation needed.

Step 4 — Handle images and attachments

If your markdown references local images (e.g. ![diagram](./assets/arch.png)), include the assets folder in the ZIP. The importer uploads them as Confluence attachments and rewires the image references automatically.

Option 3 — Automate with CI/CD (GitHub Actions / GitLab CI)

Best for: keeping Confluence permanently in sync with your repo. Every push updates the docs without anyone touching Confluence manually.

Prerequisites

You'll need two things from the Markdown Importer app:

In Confluence, go to Settings → Apps → Markdown Importer for Confluence → API tab
Click Create New Token, give it a label (e.g. ci-cd-pipeline), set an expiration, and copy it immediately
On the same page, copy your unique API endpoint URL — it looks like:

   https://your-site.atlassian.net/wiki/apps/<app-id>/<env-id>/webtrigger

Store both as secrets in your repo:
- GitHub: Settings → Secrets → CONFLUENCE_API_ENDPOINT + CONFLUENCE_API_TOKEN
- GitLab: Settings → CI/CD → Variables → same two variables

You'll also need your Confluence space ID and parent page ID — both are visible in the app's space and page selectors.

GitHub Actions Workflow

Create .github/workflows/sync-docs.yml:

name: Sync docs to Confluence

on:
  push:
    branches: [main]
    paths:
      - "docs/**"

jobs:
  sync:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Import README to Confluence
        run: |
          CONTENT=$(cat docs/README.md | jq -Rs .)
          curl -X POST "${{ secrets.CONFLUENCE_API_ENDPOINT }}" \
            -H "Authorization: Bearer ${{ secrets.CONFLUENCE_API_TOKEN }}" \
            -H "Content-Type: application/json" \
            -d "{\"spaceId\":\"DOCS\",\"parentId\":\"123456789\",\"pageTitle\":\"README\",\"content\":$CONTENT,\"overwrite\":true}"

      - name: Import API docs
        run: |
          CONTENT=$(cat docs/api.md | jq -Rs .)
          curl -X POST "${{ secrets.CONFLUENCE_API_ENDPOINT }}" \
            -H "Authorization: Bearer ${{ secrets.CONFLUENCE_API_TOKEN }}" \
            -H "Content-Type: application/json" \
            -d "{\"spaceId\":\"DOCS\",\"parentId\":\"123456789\",\"pageTitle\":\"API Reference\",\"content\":$CONTENT,\"overwrite\":true}"

The API sends one page per request as JSON — add a step per file you want to keep in sync. The workflow only triggers when files under docs/ change.

GitLab CI Pipeline

Add to .gitlab-ci.yml:

stages:
  - deploy-docs

deploy-confluence:
  stage: deploy-docs
  only:
    - main
  script:
    - |
      curl -X POST "$CONFLUENCE_API_ENDPOINT" \
        -H "Authorization: Bearer $CONFLUENCE_API_TOKEN" \
        -H "Content-Type: application/json" \
        -d "{
          \"spaceId\": \"DOCS\",
          \"parentId\": \"123456789\",
          \"pageTitle\": \"API Documentation\",
          \"content\": $(cat docs/api.md | jq -Rs .),
          \"overwrite\": true
        }"

Store CONFLUENCE_API_ENDPOINT, CONFLUENCE_API_TOKEN as masked CI/CD variables in GitLab.

Tips for a Clean Migration

Organise before you import. Rename files with a numeric prefix if you care about order (01-overview.md, 02-installation.md). The importer preserves file order when importing via the UI.

Handle frontmatter. If your docs use YAML frontmatter (like many Docusaurus or MkDocs setups), the importer reads title from frontmatter and uses it as the Confluence page title. No need to strip it out.

Check internal links. Links between pages (e.g. [see here](../api/overview.md)) are resolved relative to the page hierarchy during import. Cross-check a few after importing to confirm they resolve correctly.

Run a test import first. Pick a small subfolder, import it into a sandbox space, and confirm the output looks right before running the full migration.

Getting Started

Install Markdown Exporter & Importer for Confluence from the Atlassian Marketplace — it's free to try.

For the CI/CD approach, check out the REST API documentation for the full list of parameters, authentication details, and code examples in Node.js, Python, and Go.

Questions or edge cases? Reach out via our support portal — we're happy to help with migration planning.

Markdown Importer v6.0.0 is Here – Early Conflict Detection, Performance Updates & UI Enhancements!

Yamuno — Thu, 23 Apr 2026 13:59:12 +0000

Markdown Importer v6.0.0 is Here 🚀

We're excited to announce the release of Markdown Importer for Confluence v6.0.0! This update brings powerful new features, performance improvements, and a refreshed interface to make importing Markdown files into Confluence easier and more reliable than ever.

🌟 What's New in v6.0.0

🔍 Early Conflict Detection

One of the biggest challenges when importing files into Confluence is dealing with duplicate names for pages and folders. With v6.0.0, we've introduced early conflict detection to identify these issues before they cause problems. You'll now be able to:

Detect conflicting files and folders before importing
Choose whether to skip, or resolve conflicts directly
Save time and avoid messy post-import cleanups

⚡ Performance Updates

Large imports can now be processed faster and more efficiently. We've optimized our backend logic to handle heavy workloads, so whether you're importing a small set of documents or an entire knowledge base, you'll experience smoother and quicker performance.

🎨 UI Enhancements

We've refreshed the user interface to make the importing process more intuitive. Cleaner layouts, improved navigation, and a more modern look ensure that you can focus on your content without friction.

💡 Why This Matters

Markdown Importer is designed to help teams seamlessly bring their existing documentation into Confluence. With these improvements, you'll spend less time fixing issues and more time collaborating on what matters most. Check out our documentation to learn more about all the features.

🔗 Try It Now

Upgrade to the latest version and experience the improvements yourself:

👉 Markdown Importer for Confluence on Atlassian Marketplace

We'd love to hear your feedback! Reach out via our support channel. Your input helps us continue improving the app to better fit your workflows.

Want to see the full changelog? Visit our release notes page.

✅ Ready to import smarter, faster, and more reliably?

Update to Markdown Importer v6.0.0 today!

New Features in Markdown Importer for Confluence – Unlimited Bulk Import, Hierarchy Support, and More!

Yamuno — Thu, 23 Apr 2026 13:53:46 +0000

🚀 Big Update for Markdown Importer for Confluence!

We’ve just rolled out a major upgrade to make importing your Markdown content into Confluence faster, smarter, and more powerful than ever.

✨ What’s New

✅ Unlimited Bulk Import

Bring in as many files as you need — all at once.

✅ Folder & File Hierarchy Support

Upload ZIP files while preserving your original folder and file structure.

✅ Attachment Upload Support

Automatically include all attachments referenced in your files.

✅ Multiple Access Modes

Choose between global or per-page access controls for better security and collaboration.

Whether you’re migrating projects, organizing documentation, or collaborating at scale, this update makes it seamless.

🔗 Check it out here:
Markdown Importer for Confluence – Atlassian Marketplace

📚 Read the docs: Markdown Importer for Confluence Documentation

Introducing REST API for Markdown Importer – Automate Your Documentation Workflow!

Yamuno — Thu, 23 Apr 2026 13:53:32 +0000

Introducing REST API for Markdown Importer 🚀

We're thrilled to announce a game-changing addition to Markdown Importer for Confluence – a powerful REST API that unlocks automation and integration possibilities for your documentation workflow!

Say goodbye to manual imports and hello to seamless, programmatic documentation updates directly from your CI/CD pipeline, external applications, or custom automation scripts.

🌟 What's New in v6.4.0

The new REST API transforms how you manage Confluence documentation by enabling programmatic markdown imports from anywhere. Whether you're syncing docs from GitHub, deploying from GitLab CI/CD, or building custom integrations, the API makes it effortless.

Key Features

🔐 Secure Token Management
Generate and manage API tokens with JWT-based authentication, fine-grained expiration control (1-30 days), and the ability to create up to 50 tokens for different environments.

🚀 Simple HTTP Requests
Import markdown content with a straightforward POST request – no complex setup required.

🔄 Smart Conflict Handling
Choose to create new pages or update existing ones with built-in overwrite support and clear error handling.

📚 Comprehensive Documentation
From getting started guides to production best practices, we've got you covered with complete API documentation, code examples in multiple languages, and CI/CD workflow templates.

💡 Perfect For

CI/CD Pipelines
Automatically sync documentation with every code push. Keep your Confluence pages updated alongside your codebase without manual intervention.

Documentation Migration
Moving from another platform? Script your migration and import hundreds of markdown files programmatically with consistent formatting.

Automated Updates
Trigger documentation updates from external systems, webhooks, or scheduled jobs. Perfect for keeping release notes, changelogs, and API docs fresh.

Custom Workflows
Build exactly the integration you need – whether it's generating docs from code comments, syncing from multiple sources, or creating dynamic content.

🎯 Why It Matters

Documentation should evolve with your product, not lag behind it. The REST API eliminates the manual bottleneck, letting you:

✅ Automate repetitive import tasks
✅ Synchronize docs with code changes automatically
✅ Scale from single files to enterprise-wide migrations
✅ Integrate with your existing tools and workflows

📖 Ready to Get Started?

We've prepared comprehensive documentation to help you integrate the API into your workflow:

👉 View Complete API Documentation

Our documentation includes:

Quick start guide with step-by-step token setup
Complete API reference with all endpoints and parameters
Ready-to-use code examples in cURL, Node.js, Python, Go, and more
CI/CD workflow templates for GitHub Actions and GitLab
Production-ready best practices and troubleshooting tips

🎉 Try It Now

The REST API is available now for all Markdown Importer for Confluence users!

✅ Included with your license – No additional cost
✅ Available during trial – Test it before you buy
✅ Production-ready – Built for scale and reliability

💬 We Want Your Feedback

We'd love to hear how you're using the REST API! Share your use cases, integrations, or feedback:

📧 Contact Support
📝 View Full Changelog

Get Markdown Importer for Confluence and start automating your documentation workflow today!

Ready to automate your documentation? The REST API is waiting for you! 🚀