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

1. Install the app from the Atlassian Marketplace
2. Open any Confluence page and click ••• (More actions) → Export to PDF
3. Choose a template (or use the default)
4. Select the scope — single page, page tree, or space
5. 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.

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.

1. Open the target Confluence page where you want the content to live
2. Click the ••• (More actions) menu → Markdown Importer & Exporter
3. Select Import and choose your .md or .mdx file
4. 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

1. In Confluence, navigate to the space or page where you want the docs imported
2. Open the ••• menu → Markdown Importer & Exporter
3. Select Import and upload your docs-export.zip
4. 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:

1. In Confluence, go to Settings → Apps → Markdown Importer for Confluence → API tab
2. Click Create New Token, give it a label (e.g. ci-cd-pipeline), set an expiration, and copy it immediately
3. 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
   

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

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!

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

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! 🚀

We’re excited to announce v7.0.0 of Markdown Importer for Confluence, now featuring the all-new Markdown Exporter! 🎉

With this update, the app transitions from being Markdown Import-only to a full two-way Markdown solution — enabling teams to import Markdown files into Confluence and export Confluence pages back to clean Markdown. 💪

This addition makes documentation workflows more flexible, efficient, and automation-friendly, whether you’re syncing content with external tools, managing backups, or integrating with CI/CD pipelines.

✨ Key Features of the Exporter

📤 Export Confluence Pages to Markdown

Easily export Confluence pages to structured Markdown files, preserving page hierarchy, attachments, and formatting for smooth version control and external documentation workflows. 🗂️

📥 Import Markdown Files (Existing Feature)

Continue to import Markdown files with seamless bulk support, preserved folder structures, and accurate formatting. ⚡

🔗 Automation & REST API Support

Use REST API with JWT authentication and expiring API tokens to automate imports and exports. Built-in conflict detection ensures your workflows remain smooth. 🤖

🌙 User-Friendly Interface

Bulk operations are simple with dark mode and an intuitive UI, ideal for large-scale documentation projects. 🖥️

💡 Why Teams Love It

• ⏱ Save Time: No manual copy-paste between Markdown and Confluence
• ✅ Maintain Accuracy: Formatting, attachments, and hierarchy remain intact
• 🚀 Boost Productivity: Integrate with automated workflows, CI/CD, and external tools
• ⚡ Designed for Fast-Moving Teams: Lightweight, efficient, and reliable

🎯 Get Started Today

Experience the power of Markdown Exporter & Importer for Confluence (v7.0.0). Import Markdown, export Confluence pages, and automate your documentation workflows with ease.

👉 Get it on the Atlassian Marketplace

If you've ever tried to switch from one LaTeX math app to another in Confluence, you know the pain. Hundreds of pages, thousands of equations, all locked into a vendor-specific format. Manually re-entering every formula is not an option.

That's why we built Migration Support directly into LaTeX Math for Confluence.

The Problem

Teams across engineering, academia, and finance rely on LaTeX equations in their Confluence documentation. But what happens when your current math app doesn't cut it anymore? Maybe the rendering is slow. Maybe it lacks features you need. Maybe the pricing changed.

Whatever the reason, you're stuck. Your formulas are embedded in a proprietary macro format, scattered across dozens of spaces and hundreds of pages. Moving to a new app means either:

1. Manually finding and re-entering every single equation, or
2. Living with an app that no longer meets your needs.

Neither is acceptable.

The Solution: One-Click Migration

LaTeX Math for Confluence now includes a built-in migration tool that automatically finds, converts, and replaces equations from other LaTeX math apps across your entire Confluence instance.

Here's how it works:

Step 1: Choose Your Source App

Open the migration tab in the app's configuration settings. Select the app you're migrating from. We currently support:

• LaTeX and MathJax by The Plugin People
• LaTeX Math by Appfire
• LaTeX Math Lite by Appfire
• LaTeX Math (Easy Math) by Narva Software

Need to migrate from an app not on the list? The Advanced tab lets you enter any macro name manually.

Step 2: Search Your Spaces

Select a Confluence space to scan, or search across your entire instance. The tool uses Confluence's query language under the hood to find every page that contains equations from your source app.

Results are displayed in a clear table showing the page title, space, and last modified date so you know exactly what you're working with.

Step 3: Migrate

Select the pages you want to migrate and hit the button. The tool handles the rest:

• Extracts the LaTeX formula from the old macro format
• Converts it to the LaTeX Math for Confluence format
• Preserves alignment settings (left, center, right)
• Maps inline equations to inline macros and block equations to block macros
• Updates the page with proper version tracking

Every migration is recorded in the page's version history, so you always have a clear audit trail.

What Makes This Different

It Handles the Format Chaos

Different apps store LaTeX in wildly different ways. Some use XML parameters, others use rich text bodies, others use ADF extensions. Some wrap formulas in CDATA sections, others encode them as plain parameters.

Our migration engine understands all of these formats. It extracts your LaTeX from whatever structure the source app used and converts it cleanly.

It's Safe

Migration doesn't delete your original content. Confluence's version history means you can always roll back any page to its pre-migration state. The tool also reports success and failure counts for every batch, so you know immediately if something needs attention.

It Scales

Whether you have 10 pages or 10,000, the migration tool handles pagination and batch processing. It works through your pages methodically, updating each one and moving on, without overwhelming the Confluence API.

It's Built for Real Teams

We didn't build this for a demo. We built it because real users asked for it. Teams running thousands of equations across enterprise Confluence instances need a way to switch apps without losing a week of productivity.

Advanced Mode

For power users and admins dealing with custom or less common apps, the Advanced tab offers full control:

• Enter any macro name to search for
• Filter by body content
• Target specific spaces
• Handle edge cases that the standard wizard might not cover

Get Started

Migration support is available now in LaTeX Math for Confluence. Open your app configuration, navigate to the "Migrate from other apps" tab, and run your first search. You'll see exactly how many equations you can migrate before committing to anything.

No manual work. No lost formulas. No downtime.

Your equations deserve better. Move them in minutes, not months.

LaTeX Math for Confluence supports both KaTeX and MathJax rendering, inline and block equations, chemical formulas, physics notation, and more. Available on the Atlassian Marketplace.

We're excited to announce the launch of LaTeX Math for Confluence! Finally, you can create professional, publication-quality mathematical equations directly in your Confluence documentation with the power and precision of LaTeX.

🌟 What Makes LaTeX Math for Confluence Special

🧮 Professional Math Rendering

Create beautiful mathematical equations using the industry-standard LaTeX syntax, powered by KaTeX for fast, crisp rendering:

• Comprehensive LaTeX Support: Fractions, matrices, integrals, summations, Greek symbols, and more
• Crystal-Clear Output: High-quality rendering that looks perfect at any size
• Publication-Ready: Professional typesetting suitable for technical documentation, research papers, and educational materials

⚡ Live Preview Editor

See your equations come to life as you type:

• Real-Time Rendering: Watch your LaTeX code transform into beautiful equations instantly
• Error Detection: Catch syntax errors before saving
• Instant Feedback: No more guessing how your equation will look

📝 Flexible Macro Options

Choose the perfect format for your equations:

• Inline Macros: Embed equations within text paragraphs (like (x^2 + y^2 = r^2))
• Block Macros: Display equations prominently on their own line with proper spacing
• Easy Insertion: Type /latex or /math to insert a macro anywhere on your page

🔒 Enterprise-Grade Security

Built on Atlassian Forge for maximum security and reliability:

• Runs on Atlassian Infrastructure: No external dependencies or third-party servers
• Access Control: Configure who can view and edit equations
• User Whitelisting: Restrict equation editing to specific users or groups
• Permission Management: Granular control over macro usage

🌗 Dark Mode Support

Perfect viewing experience in any environment:

• Automatic Theme Detection: Equations adapt to your Confluence theme
• Comfortable Viewing: Optimized contrast for both light and dark modes
• Consistent Experience: Professional appearance regardless of theme preference

📊 Usage Analytics

Track and monitor equation usage across your instance:

• Usage Statistics: See how many equations are being created
• Adoption Metrics: Track macro usage over time
• Administrative Insights: Understand how your team uses mathematical documentation

💡 Why Your Team Needs This

LaTeX Math for Confluence solves the challenge of documenting technical and mathematical concepts. Instead of using screenshots, external equation editors, or compromising with plain text, you get:

🎓 Perfect for Education

• Course Materials: Create lecture notes, problem sets, and study guides
• Research Documentation: Document mathematical proofs and research findings
• Student Collaboration: Enable students to contribute mathematical content
• Assignment Templates: Build reusable templates for mathematical coursework

🔬 Ideal for Technical Teams

• Engineering Documentation: Document algorithms, formulas, and technical specifications
• Data Science: Share statistical models, machine learning equations, and data analysis
• Physics & Chemistry: Create scientific documentation with complex equations
• Architecture Diagrams: Include mathematical specifications in design documents

📚 Enhanced Knowledge Sharing

• Searchable Content: Unlike images, LaTeX equations remain searchable and accessible
• Easy Updates: Edit equations directly without recreating images
• Version Control: Track changes to equations just like any other Confluence content
• Copy & Paste: Users can copy LaTeX code for reuse in other documents

🚀 Common Use Cases

Research & Development

• Technical Specifications: Document mathematical models and algorithms
• Research Papers: Collaborate on technical documentation before publication
• Patent Documentation: Include precise mathematical descriptions
• Scientific Reports: Create comprehensive technical reports with proper notation

Education & Training

• Course Materials: Build complete courses with integrated mathematical content
• Tutorial Documentation: Create step-by-step mathematical tutorials
• Reference Guides: Maintain equation libraries and formula sheets
• Practice Problems: Share problem sets with solutions

Engineering & Data Science

• Algorithm Documentation: Explain complex algorithms with mathematical precision
• Statistical Analysis: Document statistical methods and data models
• Machine Learning: Share model architectures and optimization functions
• Performance Metrics: Define KPIs and measurement formulas

Finance & Quantitative Analysis

• Financial Models: Document pricing models and risk calculations
• Investment Strategies: Share quantitative trading algorithms
• Economic Analysis: Present economic models and forecasts
• Actuarial Documentation: Create actuarial tables and calculations

🔗 Get Started Today

Ready to bring professional mathematical notation to your Confluence workspace?

👉 Install LaTeX Math for Confluence

Quick Start Guide

1. Install the App: Add LaTeX Math from the Atlassian Marketplace
2. Insert a Macro: Type /latex or /math on any Confluence page
3. Choose Your Style: Select inline (within text) or block (standalone) macro
4. Write LaTeX: Enter your LaTeX equation code
5. See It Live: Watch the real-time preview as you type
6. Save & Share: Publish your page with beautiful mathematical equations

Example LaTeX Snippets to Try

Quadratic Formula:

x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}

Pythagorean Theorem:

a^2 + b^2 = c^2

Integral:

\int_{a}^{b} f(x) \, dx

Matrix:

\begin{bmatrix}
a & b \\
c & d
\end{bmatrix}

📚 Learn More

Explore our comprehensive documentation to master all features:

👉 LaTeX Math for Confluence Documentation

Need Help?

• Quick Reference: Browse our LaTeX syntax guide in the documentation
• Support Team: Reach out via our support portal
• FAQs: Check our documentation for common questions and solutions

✨ Transform Your Technical Documentation

Whether you're documenting complex algorithms, teaching advanced mathematics, or sharing scientific research, LaTeX Math for Confluence gives you the tools to communicate with precision and clarity.

Start creating beautiful equations today!

Have questions or feedback? We'd love to hear from you via our support portal. Your input helps us continue improving our apps to better serve your team's needs.

Most data science teams have the same documentation problem: the math lives somewhere else.

Loss functions in a Jupyter notebook. Model architecture equations in a Google Doc. Evaluation metrics in a Slack thread. Confluence ends up as a project tracker rather than a real knowledge base — because there was no good way to write math in it.

LaTeX Math for Confluence changes that. Here's how teams are using it to actually document their models.

The Problem with Screenshots and Plain Text

The two common workarounds both have obvious failure modes.

Screenshots look fine on day one. Then the model changes, the screenshot is wrong, and nobody updates it because re-exporting from LaTeX or Overleaf and re-uploading feels like too much work. Six months later, the page has equations that don't match the code.

Plain text approximations (loss = -sum(y * log(y_hat))) are readable to the author but lose precision fast. No Greek letters, no proper fractions, no summation notation. Anyone reading the doc has to mentally parse notation that doesn't match what they'd write on a whiteboard.

Documenting Models with LaTeX in Confluence

With LaTeX Math, you type /latex or /math on any Confluence page and get a live editor. Equations render in real time as you type, and you can choose inline (within a sentence) or block (standalone, centered) layout.

Here's how it maps to the kinds of things data science teams actually write.

Loss Functions

The cross-entropy loss for a classification model:

\mathcal{L} = -\frac{1}{N} \sum_{i=1}^{N} \sum_{c=1}^{C} y_{ic} \log(\hat{y}_{ic})

Mean squared error:

\mathcal{L}_{MSE} = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y}_i)^2

Binary cross-entropy:

\mathcal{L} = -\frac{1}{N} \sum_{i=1}^{N} \left[ y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i) \right]

These go inline in a model card, in a section right next to the architecture description and training configuration — all in one Confluence page that anyone on the team can find.

Activation Functions

Documenting why you chose a particular activation is easier when you can show it properly.

ReLU:

f(x) = \max(0, x)

Sigmoid:

\sigma(x) = \frac{1}{1 + e^{-x}}

Softmax (for a vector z of length K):

\text{softmax}(z_j) = \frac{e^{z_j}}{\sum_{k=1}^{K} e^{z_k}}

GELU (common in transformer models):

\text{GELU}(x) = x \cdot \Phi(x)

Evaluation Metrics

Precision and recall written in plain text are fine. Written as equations they're unambiguous:

\text{Precision} = \frac{TP}{TP + FP}
\qquad
\text{Recall} = \frac{TP}{TP + FN}

F1 score:

F_1 = 2 \cdot \frac{\text{Precision} \cdot \text{Recall}}{\text{Precision} + \text{Recall}}

AUROC is harder to describe in words than in math:

\text{AUROC} = \int_0^1 \text{TPR}(t) \, d(\text{FPR}(t))

Regularisation and Optimisers

L2 regularisation added to a loss term:

\mathcal{L}_{reg} = \mathcal{L} + \lambda \sum_{j} w_j^2

Adam update rule — the kind of thing that should live in your training runbook:

m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t
\qquad
v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2

\hat{m}_t = \frac{m_t}{1 - \beta_1^t}
\qquad
\hat{v}_t = \frac{v_t}{1 - \beta_2^t}

\theta_{t+1} = \theta_t - \frac{\eta}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t

Bayesian and Probabilistic Models

Teams doing probabilistic modelling or Bayesian inference often have the worst documentation problem — Bayes' theorem in a Slack message is a disaster. In Confluence it's clean:

P(\theta \mid X) = \frac{P(X \mid \theta) \, P(\theta)}{P(X)}

KL divergence between two distributions:

D_{KL}(P \| Q) = \sum_{x} P(x) \log \frac{P(x)}{Q(x)}

ELBO for variational inference:

\mathcal{L}(\phi, \theta) = \mathbb{E}_{q_\phi(z|x)} \left[ \log p_\theta(x|z) \right] - D_{KL}\left( q_\phi(z|x) \| p(z) \right)

What a Model Card Looks Like in Practice

A typical model card in Confluence might be structured like this:

• Overview — what the model does, who it's for
• Architecture — layer counts, attention heads, embedding dimensions (inline equations for shapes)
• Training objective — loss function as a block equation
• Optimiser — learning rate, weight decay, scheduler (formulas inline in a table)
• Evaluation — metrics defined as equations, results as a table
• Known limitations — plain text

With LaTeX Math, the equations in that document are live, editable, and match the actual implementation. When a team member updates the model and changes the loss function, they update the equation directly — no re-exporting, no new screenshots, no broken images.

Getting Started

Install LaTeX Math for Confluence from the Atlassian Marketplace. On any Confluence page, type /latex to insert a block equation or /math for an inline equation.

Full documentation is at LaTeX Math for Confluence docs.

Questions? Reach out via our support portal.

Confluence is a solid documentation platform. But the moment you need a colored status badge, a countdown to your launch date, or a table that users can actually sort — you hit a wall. Native macros only go so far.

HTML Macro for Confluence fills that gap. It lets you drop a full HTML/CSS/JS editor directly into any Confluence page. Live preview, CSP security controls, granular access permissions — and it runs entirely on Atlassian Forge with nothing sent to external servers.

Here are five concrete things teams are building with it right now.

1. Custom Status Badge / Traffic Light Indicator

The problem: Your project status page needs a RAG (Red/Amber/Green) indicator that's quick to read and easy for editors to update. The native Confluence status macro is limited, and color-coded text doesn't stand out enough for at-a-glance checks.

The solution: A simple HTML/CSS badge with a colored circle and a label. Editors change one word to flip the status.

<!-- HTML -->
<div class="rag-badge">
  <span class="dot green"></span>
  <span class="label">On Track</span>
</div>

/* CSS */
.rag-badge {
  display: flex;
  align-items: center;
  gap: 10px;
  font-family: sans-serif;
  font-size: 16px;
  font-weight: 600;
}

.dot {
  width: 18px;
  height: 18px;
  border-radius: 50%;
  display: inline-block;
  flex-shrink: 0;
}

.dot.green  { background-color: #22c55e; box-shadow: 0 0 8px #22c55e88; }
.dot.amber  { background-color: #f59e0b; box-shadow: 0 0 8px #f59e0b88; }
.dot.red    { background-color: #ef4444; box-shadow: 0 0 8px #ef444488; }

.label { color: #1e293b; }

Why it's useful: Swap green → amber → red on the dot class and update the label text. That's the entire update. No Confluence macros to reconfigure, no separate status apps to install. Engineers, PMs, and project leads can glance at a page and immediately know where things stand.

2. Embedded Countdown Timer

The problem: Your team has a product launch date, a sprint end, or a compliance deadline coming up. A static date in the page body gets ignored. Teams want something that actively reminds them how much runway is left.

The solution: A JavaScript countdown that calculates days, hours, and minutes remaining from a target date, updating every second.

<!-- HTML -->
<div class="countdown-wrapper">
  <div class="countdown-title">Launch Countdown</div>
  <div class="countdown-timer">
    <div class="unit"><span id="days">--</span><label>Days</label></div>
    <div class="unit"><span id="hours">--</span><label>Hours</label></div>
    <div class="unit"><span id="minutes">--</span><label>Minutes</label></div>
  </div>
</div>

/* CSS */
.countdown-wrapper { font-family: sans-serif; text-align: center; padding: 24px; background: #f8fafc; border-radius: 12px; }
.countdown-title { font-size: 14px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.08em; color: #64748b; margin-bottom: 16px; }
.countdown-timer { display: flex; justify-content: center; gap: 24px; }
.unit { display: flex; flex-direction: column; align-items: center; }
.unit span { font-size: 48px; font-weight: 700; color: #1e293b; line-height: 1; }
.unit label { font-size: 12px; color: #94a3b8; margin-top: 4px; text-transform: uppercase; letter-spacing: 0.06em; }

// JavaScript — set your target date here
const target = new Date("2026-05-01T09:00:00");

function tick() {
  const diff = target - new Date();
  if (diff <= 0) {
    document.querySelector(".countdown-timer").innerHTML = "<p>We're live!</p>";
    return;
  }
  document.getElementById("days").textContent    = Math.floor(diff / 86400000);
  document.getElementById("hours").textContent   = Math.floor((diff % 86400000) / 3600000);
  document.getElementById("minutes").textContent = Math.floor((diff % 3600000) / 60000);
}

tick();
setInterval(tick, 1000);

Why it's useful: Change one date string and you have a live countdown that works for any milestone. Sprint reviews, feature freezes, go-live dates — it's a passive but effective nudge every time someone opens the page.

3. Interactive Decision Tree for Runbooks

The problem: Runbooks and incident response guides are often long, linear documents. Engineers in the middle of an incident don't want to read paragraphs — they want to answer a question and be told exactly what to do next.

The solution: A clickable HTML/CSS decision tree that walks users through branching logic step by step. No external charting library required.

<!-- HTML -->
<div class="tree" id="tree">
  <div class="node active" id="q1">
    <p>Is the service returning errors?</p>
    <div class="choices">
      <button onclick="show('q1-yes')">Yes</button>
      <button onclick="show('q1-no')">No</button>
    </div>
  </div>
  <div class="node" id="q1-yes">
    <p>Are errors 5xx (server-side)?</p>
    <div class="choices">
      <button onclick="show('check-logs')">Yes</button>
      <button onclick="show('check-upstream')">No</button>
    </div>
  </div>
  <div class="node answer" id="check-logs">
    <p>Check application logs in Datadog. Look for OOM errors or unhandled exceptions. Page the on-call engineer if needed.</p>
    <button onclick="reset()">Start over</button>
  </div>
  <div class="node answer" id="check-upstream">
    <p>Likely a 4xx or gateway issue. Check upstream dependencies and API gateway logs.</p>
    <button onclick="reset()">Start over</button>
  </div>
  <div class="node answer" id="q1-no">
    <p>Service appears healthy. Check monitoring dashboards for latency spikes or queue depth issues.</p>
    <button onclick="reset()">Start over</button>
  </div>
</div>

/* CSS */
.tree { font-family: sans-serif; max-width: 480px; }
.node { display: none; padding: 20px; border: 1px solid #e2e8f0; border-radius: 10px; margin-bottom: 12px; background: #fff; }
.node.active { display: block; }
.node p { margin: 0 0 14px; font-size: 15px; color: #1e293b; font-weight: 500; }
.choices { display: flex; gap: 10px; }
button { padding: 8px 18px; border: none; border-radius: 6px; background: #6366f1; color: #fff; font-size: 14px; cursor: pointer; }
button:hover { background: #4f46e5; }
.answer { background: #f0fdf4; border-color: #86efac; }
.answer p { color: #166534; font-weight: 400; }
.answer button { background: #64748b; }

// JavaScript
function show(id) {
  document.querySelectorAll(".node").forEach(n => n.classList.remove("active"));
  document.getElementById(id).classList.add("active");
}
function reset() { show("q1"); }

Why it's useful: Runbook authors can build arbitrarily deep trees using just HTML — no Mermaid, no Lucidchart license needed. The tree lives inside the Confluence page, is searchable, and can be updated by anyone with access to the macro editor.

4. Custom Data Table with Sort and Filter

The problem: Confluence tables are static. You can't click a column header to sort, and there's no filter input. For any table with more than a dozen rows — vendor lists, feature matrices, environment configs — this is a real usability problem.

The solution: A vanilla JavaScript snippet that adds click-to-sort to any HTML table, plus a live filter input.

<!-- HTML -->
<div class="table-wrapper">
  <input id="filter" type="text" placeholder="Filter rows..." />
  <table id="data-table">
    <thead>
      <tr>
        <th>Service</th>
        <th>Owner</th>
        <th>Status</th>
        <th>SLA</th>
      </tr>
    </thead>
    <tbody>
      <tr><td>Auth API</td><td>Platform</td><td>Healthy</td><td>99.9%</td></tr>
      <tr><td>Billing</td><td>Payments</td><td>Degraded</td><td>99.5%</td></tr>
      <tr><td>Notifications</td><td>Growth</td><td>Healthy</td><td>99.0%</td></tr>
      <tr><td>Search</td><td>Platform</td><td>Healthy</td><td>99.9%</td></tr>
      <tr><td>Analytics</td><td>Data</td><td>Maintenance</td><td>98.0%</td></tr>
    </tbody>
  </table>
</div>

/* CSS */
.table-wrapper { font-family: sans-serif; }
#filter { width: 100%; padding: 8px 12px; margin-bottom: 12px; border: 1px solid #cbd5e1; border-radius: 6px; font-size: 14px; box-sizing: border-box; }
table { width: 100%; border-collapse: collapse; font-size: 14px; }
th { background: #f1f5f9; padding: 10px 14px; text-align: left; cursor: pointer; user-select: none; border-bottom: 2px solid #e2e8f0; color: #475569; }
th:hover { background: #e2e8f0; }
td { padding: 10px 14px; border-bottom: 1px solid #f1f5f9; color: #1e293b; }
tr:hover td { background: #f8fafc; }
th.asc::after  { content: " ▲"; font-size: 11px; }
th.desc::after { content: " ▼"; font-size: 11px; }

// JavaScript
const table = document.getElementById("data-table");
const tbody = table.querySelector("tbody");
const headers = table.querySelectorAll("th");
let sortCol = -1, sortAsc = true;

headers.forEach((th, i) => {
  th.addEventListener("click", () => {
    if (sortCol === i) { sortAsc = !sortAsc; } else { sortCol = i; sortAsc = true; }
    headers.forEach(h => h.classList.remove("asc", "desc"));
    th.classList.add(sortAsc ? "asc" : "desc");
    const rows = Array.from(tbody.querySelectorAll("tr"));
    rows.sort((a, b) => {
      const av = a.cells[i].textContent.trim();
      const bv = b.cells[i].textContent.trim();
      return sortAsc ? av.localeCompare(bv) : bv.localeCompare(av);
    });
    rows.forEach(r => tbody.appendChild(r));
  });
});

document.getElementById("filter").addEventListener("input", function () {
  const q = this.value.toLowerCase();
  tbody.querySelectorAll("tr").forEach(row => {
    row.style.display = row.textContent.toLowerCase().includes(q) ? "" : "none";
  });
});

Why it's useful: Replace the <tbody> rows with your actual data and you have a fully sortable, filterable table with zero dependencies. Works for service registries, on-call rosters, feature flags, release checklists — anything that lives in a Confluence table but deserves better UX.

5. Branded Announcement Banner

The problem: HR needs to announce open enrollment. Marketing wants to flag a product launch to all readers of a space. The built-in Confluence info panel is functional but bland — it doesn't match company branding and blends into the page noise.

The solution: A CSS-styled announcement banner with a company-colored left border, an icon, a headline, and body text. Completely customizable.

<!-- HTML -->
<div class="announcement">
  <div class="announcement-icon">📣</div>
  <div class="announcement-body">
    <div class="announcement-title">Open Enrollment — Action Required</div>
    <div class="announcement-message">
      Benefits enrollment is open until <strong>April 30, 2026</strong>.
      Log in to Workday and complete your selections before the deadline.
      Contact <a href="mailto:hr@company.com">hr@company.com</a> with questions.
    </div>
  </div>
</div>

/* CSS */
.announcement {
  display: flex;
  align-items: flex-start;
  gap: 16px;
  padding: 18px 20px;
  border-left: 5px solid #6366f1;
  background: #eef2ff;
  border-radius: 0 10px 10px 0;
  font-family: sans-serif;
  max-width: 680px;
}

.announcement-icon {
  font-size: 24px;
  flex-shrink: 0;
  margin-top: 2px;
}

.announcement-title {
  font-size: 15px;
  font-weight: 700;
  color: #3730a3;
  margin-bottom: 6px;
}

.announcement-message {
  font-size: 14px;
  color: #1e293b;
  line-height: 1.6;
}

.announcement-message a {
  color: #6366f1;
  text-decoration: none;
  font-weight: 500;
}

.announcement-message a:hover { text-decoration: underline; }

Why it's useful: Change the border color and background tint to match your brand palette, swap in your own headline and message, and you have a polished callout that actually gets noticed. No graphic design skills needed, and the same template works for IT alerts, policy updates, and event announcements.

A Note on Security

Embedding HTML and JavaScript in a documentation platform is a responsibility that admins need to control. HTML Macro for Confluence gives you three Content Security Policy modes:

• Block All — the strictest setting. No external resources (scripts, fonts, images) can load. This is the right default for pure HTML/CSS snippets like the badge and banner examples above.
• Whitelist — you specify exactly which external domains are permitted. If your team uses Chart.js from a CDN or embeds a Google Map, you add those domains to the allowlist and nothing else gets through.
• Allow All — fully permissive. Appropriate for tightly controlled internal environments where you trust every editor.

Combined with editor access control — which limits who can open the code editor in the first place — you can let most teams use the rendered output without ever exposing the source code.

Try It Free

All five of the examples above work today, without any paid tier, without any external server, and without leaving Confluence.

HTML Macro for Confluence is free on the Atlassian Marketplace. Install it, drop it into a page, and paste in one of the snippets above to see the live preview update as you type.

Install HTML Macro for Confluence — free on the Atlassian Marketplace

Have a use case we didn't cover? We'd love to hear what your team builds. Reach out through our support portal.

We're thrilled to announce that HTML Macro for Confluence is now live on the Atlassian Marketplace — and it's free!

Confluence is great for documentation, but sometimes you need more than what native macros can offer. Now you can embed fully custom HTML, CSS, and JavaScript directly inside any Confluence page — interactive charts, branded sections, custom embeds, you name it.

What Is HTML Macro for Confluence?

HTML Macro for Confluence is a Forge-native Confluence Cloud app that lets you insert a rich code editor directly into any page. Write HTML, CSS, and JavaScript with syntax highlighting, see a live preview as you type, and publish polished interactive content — all without leaving Confluence.

Key Features

Code Editor with Live Preview

The macro opens a three-tab editor (HTML, CSS, JS) with syntax highlighting. A resizable split panel shows the rendered output in real time as you type — no more guessing how your code will look once saved.

Enterprise-Grade CSP Security

Security is built in, not bolted on. Admins choose from three Content Security Policy modes:

• Block All — no external resources allowed (strictest, default)
• Whitelist — only domains you explicitly approve can load resources
• Allow All — unrestricted, for trusted internal environments

This means you can let teams use Chart.js, Google Maps, or YouTube embeds safely — by whitelisting only the domains you trust.

Editor Access Control

Not everyone on a page should be able to edit embedded code. HTML Macro lets admins whitelist specific users who can open the code editor. Everyone else sees only the rendered output — source code stays private.

Automatic iframe Height

The macro auto-adjusts its iframe height to match the content — no fixed heights to set, no awkward blank space below your widget.

Macro Usage Analytics

Admins get a dashboard showing every Confluence page using the HTML Macro across the entire instance, with space breakdowns and direct page links. Understand adoption and audit usage in seconds.

Runs Entirely on Atlassian Forge

HTML Macro for Confluence is 100% Forge-native. All content is stored inside Atlassian's infrastructure. Nothing is sent to external servers — ever.

What Can You Build?

Here are a few things teams are already building with HTML Macro for Confluence:

• Interactive dashboards using Chart.js or D3.js
• Branded internal landing pages with custom CSS layouts
• Embedded maps via Google Maps or Leaflet
• Video embeds (YouTube, Vimeo) with custom styling
• Custom tables and data grids with sorting and filtering
• Onboarding checklists and interactive forms
• Countdown timers and status banners

If you can build it with HTML, CSS, and JavaScript — you can put it in Confluence.

Getting Started

1. Install the app from the Atlassian Marketplace
2. Open any Confluence page and type /HTML Macro
3. Write your HTML, CSS, and JavaScript in the editor
4. See the live preview update as you type
5. Save and publish — your content is live

Free on the Marketplace

HTML Macro for Confluence is available for free. Install it today and start building richer Confluence pages in minutes.

👉 Install HTML Macro for Confluence

👉 Read the Documentation

Questions or feedback? Reach out via our support portal — we'd love to hear what you build with it.

Confluence is where your team documents things. Markdown is where developers write things. The problem is they don't naturally talk to each other — pasting markdown into Confluence turns your beautiful formatting into a wall of symbols.

Markdown Importer for Confluence & Markdown Exporter bridges that gap. Here's exactly how to use it to get markdown into Confluence — whether that's a single file, a folder of docs, or an entire GitHub repository.

Option 1 — Import a Single Markdown File

Best for: a single README, a runbook, an architecture decision record, or any standalone document.

1. Open any Confluence space and navigate to where you want the page
2. Click Apps → Markdown Importer
3. Click Import Files and upload your .md or .mdx file
4. Preview the rendered output
5. Select the parent page (or leave it at the space root)
6. Click Import

Your page is created with all formatting intact — headings, tables, code blocks, images, and lists all convert cleanly.

Option 2 — Import a Folder of Markdown Files

Best for: importing a docs folder from a project, a wiki from GitHub/GitLab, or any set of related documents that form a hierarchy.

1. Zip your markdown folder (preserving the folder structure)
2. Open Markdown Importer from the Apps menu
3. Click Import Files and upload the ZIP
4. The importer reads your folder structure and maps it to a Confluence page hierarchy
5. Preview the page tree — reorder or exclude pages as needed
6. Select the parent page in Confluence
7. Click Import

The folder hierarchy becomes your Confluence page tree:

docs/
├── getting-started/
│   ├── index.md        → Getting Started (parent)
│   ├── installation.md → Installation (child)
│   └── quick-start.md  → Quick Start (child)
└── features/
    ├── index.md        → Features (parent)
    └── api.md          → API Reference (child)

Internal links between files are automatically converted to Confluence page links — cross-references stay intact.

Option 3 — Import from a GitHub or GitLab Repository

Best for: syncing developer documentation directly from source control into Confluence — keeping your /docs folder and your Confluence space in sync.

1. Open Markdown Importer from the Apps menu
2. Click Import from URL
3. Paste your GitHub or GitLab repository URL (or a specific folder URL)
4. The importer fetches your markdown files directly from the repo
5. Preview the page tree
6. Select the destination in Confluence
7. Click Import

This is the fastest path from a Git repo to Confluence — no need to clone locally, zip files, or manually copy content.

Option 4 — Import via REST API (Automated Pipelines)

Best for: CI/CD pipelines, documentation-as-code workflows, and teams that want to automatically sync docs on every commit.

The Markdown Importer exposes a REST API that lets you trigger imports programmatically. Add it to your CI pipeline and your Confluence pages update automatically whenever your docs change.

See the REST API documentation for full details.

What Gets Preserved

The importer handles the full range of standard markdown formatting:

• Headings — H1–H6 map to Confluence heading levels
• Text formatting — bold, italic, strikethrough, inline code
• Tables — including alignment and header rows
• Code blocks — with language and syntax highlighting
• Lists — ordered, unordered, nested, and task lists with checkboxes
• Images — uploaded as Confluence attachments and linked inline
• Blockquotes — converted to Confluence info/note panels
• Links — external URLs preserved; internal .md links converted to Confluence page links
• Frontmatter — YAML frontmatter is parsed (title, date, author, tags can map to page properties)

Tips

Check your image paths. If your markdown references images with relative paths, make sure the images are included in your ZIP or accessible at the URL before importing.

Use frontmatter for page titles. If your files have title: in the YAML frontmatter, the importer uses that as the Confluence page title instead of the filename.

Import into a staging space first. For large imports, run it in a test space before hitting production. It's easy to re-import if anything looks off.

Bulk import is unlimited. There's no cap on how many pages you can import in one go — import an entire repository if you need to.

Getting Started

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

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

Questions? Reach out via our support portal.

Confluence's native PDF export exists, but it's hard to love. No cover page. No custom headers or footers. No watermarks. No way to save a template so your next export looks like the last one. For internal drafts that's fine — but for anything going to a client, executive, or auditor, you need something better.

This guide walks through how to export Confluence pages to polished, consistently formatted PDFs using PDF Exporter for Confluence.

Before You Start

Install PDF Exporter for Confluence from the Atlassian Marketplace. It runs on Atlassian Forge, so no external servers and no data leaving your Atlassian environment.

If your team has a standard export format, ask your Confluence admin to set up a template first (covered below) — then everyone gets consistent output without any manual configuration.

Option 1 — Export a Single Page

Best for: a spec, a runbook, a proposal, a one-page summary.

1. Navigate to the Confluence page you want to export
2. Click ••• (More actions) in the top-right toolbar
3. Select Export to PDF
4. Choose a template, or leave it as default
5. Click Export and download the PDF

That's it. The page content, images, tables, and code blocks are all rendered cleanly into the PDF.

Option 2 — Export a Page Tree

Best for: product documentation, a project wiki, a client handover package, or any multi-page document with a logical hierarchy.

1. Navigate to the parent page of the section you want to export
2. Click ••• → Export to PDF
3. Select Include Child Pages
4. Review the page tree — uncheck any pages to exclude
5. Choose your template
6. Click Export

The exporter processes all selected pages and bundles them into a single ZIP archive. Each page becomes its own PDF, organized to match your Confluence page hierarchy.

If you've enabled the Table of Contents option in your template, each PDF will include an auto-generated TOC built from the page headings.

Option 3 — Export an Entire Space

Best for: compliance archives, full project handovers, or regular documentation backups.

1. Open the Apps menu in the Confluence global navigation
2. Select PDF Exporter
3. Choose Export Space
4. Select the space you want to export
5. Choose a template and configure options
6. Click Export Space

Large spaces may take a few minutes to process. Keep the tab open. When complete, download the ZIP containing all your exported PDFs.

Setting Up Export Templates (Admins)

Templates are the most powerful feature in PDF Exporter. They let admins define a standard format once — and every user on the instance applies it with one click.

To create a template:

1. Go to Confluence Settings → PDF Exporter
2. Click New Template
3. Configure the template options:

Cover Page

• Toggle the cover page on or off
• Choose from six built-in cover styles
• Set your accent color, upload your company logo, and add a default subtitle

Headers & Footers

• Add custom text, page numbers, or the export date to headers and footers
• Set different content for left, center, and right positions

Watermark

• Add a watermark text (e.g. "CONFIDENTIAL", "DRAFT", "FOR REVIEW") that appears on every page

Table of Contents

• Enable auto-generated TOC from page headings
• Set heading depth (H1 only, H1–H2, H1–H3, etc.)

Fonts & Layout

• Set font size, line height, and page margins

• Save the template — it's now available to all users on the instance

What Gets Preserved in the Export

PDF Exporter handles all standard Confluence content:

• Text formatting — bold, italic, headings H1–H6, strikethrough
• Tables — including headers and column alignment
• Code blocks — with syntax highlighting preserved
• Lists — ordered, unordered, nested
• Images and attachments — rendered inline in the PDF
• Info, warning, and note panels — styled appropriately
• Page titles — used as the PDF section title

Common Use Cases

Client-Facing Documentation

Export a product spec or integration guide with your company logo on the cover, your accent color, and a clean header on every page. Looks like a designed document, not a Confluence printout.

Compliance Archiving

Export your security policies, SOPs, or audit trails to PDF with a "CONFIDENTIAL" watermark and page numbers. Maintain consistent formatting across every export with a locked-down admin template.

Stakeholder Reports

Export sprint retrospectives, project status pages, or roadmap docs to a clean PDF that stakeholders can read without needing access to Confluence.

Documentation Handovers

When handing off a project, export the full page tree as a ZIP of PDFs. The client gets a complete, structured documentation package they can archive or share internally.

Tips

Use templates consistently. Set up one template per document type (e.g. "Client Docs", "Internal Reports", "Compliance Archive") and your team will never have to configure formatting manually.

Preview before exporting large trees. For big hierarchies, check a single page first to confirm the template output looks right before running the full export.

Combine with Markdown Exporter. Need both PDF and Markdown versions? Use PDF Exporter for shareable documents and Markdown Exporter for Git-friendly backups — both run from the same ••• menu.

Getting Started

Install PDF Exporter for Confluence from the Atlassian Marketplace.

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

Questions? Reach out via our support portal.

There are plenty of reasons you might need your Confluence docs in markdown — migrating to another platform, publishing to a static site, syncing with a Git repo, or just keeping an offline backup. Whatever the reason, Confluence's built-in export doesn't give you clean markdown. It gives you HTML or PDF.

Markdown Exporter & Importer for Confluence fills that gap. Here's exactly how to use it.

Option 1 — Export a Single Page

Best for: grabbing one page quickly — a README, an architecture doc, a runbook.

1. Navigate to the Confluence page you want to export
2. Click ••• (More actions) in the top-right
3. Select Export to Markdown
4. Choose Single Page Only
5. Click Export and download the .md file

The exported file includes all inline images and attachments (downloaded locally), code blocks with syntax highlighting, tables, lists, and formatting. Images are referenced with relative paths so they stay linked correctly.

Option 2 — Export a Page Tree

Best for: exporting a section of your docs — e.g. a product's documentation, a project wiki, or an onboarding guide.

1. Navigate to the parent page
2. Click ••• → Export to Markdown
3. Choose Include Child Pages
4. Review the page tree preview — uncheck any pages you want to skip
5. Click Export and download the ZIP

The ZIP preserves your page hierarchy as folders:

confluence-export/
├── Getting Started/
│   ├── index.md
│   ├── Installation.md
│   └── Quick Start.md
├── Features/
│   ├── index.md
│   └── API Reference.md
└── attachments/
    ├── Getting Started/
    │   └── screenshot.png
    └── Features/
        └── diagram.png

Internal links between pages are converted to relative markdown links, so cross-references stay intact.

Option 3 — Export an Entire Space

Best for: full space backups, platform migrations, or archiving completed projects.

1. Open the app from the Apps menu in Confluence
2. Switch to Export mode
3. Select the space you want to export
4. Review the summary (page count, size estimate)
5. Click Export Space
6. Wait for processing — large spaces can take a few minutes
7. Download the complete ZIP archive

The output structure mirrors your Confluence space, with all pages, child pages, and attachments organized in folders matching the page tree.

What Gets Preserved

The exporter converts all standard Confluence content to clean markdown:

• Text formatting — bold, italic, strikethrough, headings H1–H6
• Tables — including column alignment and header rows
• Code blocks — with language and syntax highlighting preserved
• Lists — ordered, unordered, nested, task lists with checkboxes
• Images & attachments — downloaded and referenced with relative paths
• Info/warning/note panels — converted to blockquotes
• Internal links — converted to relative markdown links
• Page metadata — optionally exported as YAML frontmatter

Common Use Cases

Publish to a Static Site

Export your Confluence space and drop it straight into MkDocs, Docusaurus, or Jekyll. The folder structure and relative links work out of the box with most static site generators.

Sync with a Git Repository

Export your docs, push them to a docs/ folder in your repo, and your Confluence content is now version-controlled. You can reverse the flow too — edit in Git, import back to Confluence with the same app.

Migrate to Another Platform

Markdown is the closest thing to a universal documentation format. Export from Confluence, then import into Notion, GitHub Wiki, GitLab Wiki, or wherever you're moving.

Backup

Run a space export regularly and store the ZIP in S3, Google Drive, or a Git repo. It's a lightweight, readable backup you can actually open without special software.

Tips

Start small. Export a single page or a small section first to check the output before running a full space export.

Large spaces take time. Keep the browser tab open during export — closing it can interrupt the process.

Check complex macros. Most Confluence macros convert cleanly, but heavily customised layouts may need a manual review after export.

Use frontmatter for tracking. Enable the metadata option to include page titles, IDs, and dates as YAML frontmatter — useful if you're building a pipeline that needs to track which pages have changed.

Getting Started

Install Markdown Exporter & Importer for Confluence from the Atlassian Marketplace — free to try, no credit card required.

Full export documentation is at /docs/markdown-importer-for-confluence.

Questions? Reach out via our support portal.

Confluence is excellent for documentation — but if you try to write a mathematical equation natively, you'll quickly discover it has no support for it. No LaTeX renderer, no equation editor, no formula blocks. Just plain text.

For engineers, data scientists, researchers, and educators, this is a real problem. LaTeX Math for Confluence solves it — adding full LaTeX rendering powered by MathJax directly inside Confluence Cloud.

What Is LaTeX?

LaTeX is the standard notation system for mathematical, scientific, and engineering formulas. It's used in academic papers, research docs, and technical specifications worldwide.

A simple example — the quadratic formula written in LaTeX:

x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}

Which renders as the familiar formula you learned in school. LaTeX Math for Confluence turns that syntax into a properly rendered equation inside your Confluence page.

Adding an Inline Equation

Inline equations appear within a line of text — perfect for referencing variables or simple expressions mid-sentence.

1. Open a Confluence page in edit mode
2. Type /LaTeX Inline to insert the inline macro
3. Type your LaTeX expression inside the macro
4. The equation renders inline with your text

Example: Writing E = mc^2 inline renders Einstein's mass-energy equivalence right inside your sentence.

Adding a Block Equation

Block equations display on their own line, centred — ideal for key formulas, derivations, or anything you want to stand out.

1. Open a Confluence page in edit mode
2. Type /LaTeX Block to insert the block macro
3. Write your LaTeX inside the macro
4. The equation renders as a centred display formula

Example: A block equation for the normal distribution probability density function:

f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{1}{2}\left(\frac{x-\mu}{\sigma}\right)^2}

Live Preview as You Type

You don't have to save the page to see how your formula looks. The LaTeX macro includes a live preview panel that renders your equation in real time as you type. If you make a syntax error, it flags it immediately — no more saving, checking, editing, saving again.

Common LaTeX Expressions for Confluence

Here are a few frequently used formulas to get started:

Who Uses LaTeX Math for Confluence?

Data science and ML teams — document model architectures, loss functions, and statistical methods alongside their methodology notes.

Engineering teams — write technical specs with signal processing formulas, control system equations, or physics derivations.

Finance teams — document quantitative models, pricing formulas, and risk calculations.

Educators and researchers — publish course materials, research summaries, and academic content directly in Confluence.

Academic institutions — use Confluence as a shared knowledge base where equations are first-class content.

Access Control for Admins

Not every team needs LaTeX editing rights. LaTeX Math for Confluence lets admins control who can insert and edit macros — so you can restrict formula editing to specific users while everyone else reads the rendered output.

Runs on Atlassian Forge

LaTeX Math for Confluence is built on Atlassian Forge — all rendering happens within Atlassian's infrastructure. No data is sent to external servers.

Getting Started

1. Install LaTeX Math for Confluence from the Atlassian Marketplace
2. Open any Confluence page in edit mode
3. Type /LaTeX Inline or /LaTeX Block
4. Start writing equations

Full documentation: /docs/latex-math-for-confluence

Questions? Reach out via our support portal.

When teams evaluate Atlassian Marketplace apps, most conversations start with features.

In reality, adoption often depends on a different question:

How and where does this app handle our data?

If you're a Jira admin, Confluence admin, or part of an IT/security team, this guide gives you a practical way to evaluate app architecture before rollout.

🏗️ Why architecture should be reviewed first

A powerful app is still a bad fit if it creates friction with security review, procurement, or compliance requirements.

Architecture decisions directly affect:

• how quickly your app gets approved
• how easily your team can justify risk posture
• how confidently stakeholders can scale usage

That's why it helps to assess hosting model first, then compare feature depth.

⚖️ Forge-native vs externally hosted (in plain language)

Forge-native apps

Forge-native apps run on Atlassian's platform and use Atlassian-managed infrastructure patterns.

For many teams, that means security review conversations are often simpler because the model aligns closely with existing Atlassian trust expectations.

Externally hosted apps

Externally hosted apps may process data outside Atlassian-managed infrastructure.

This can still be valid depending on your policy — but usually requires deeper review around data flow, storage location, access controls, incident handling, and vendor operations.

✅ 10-point security checklist for Marketplace app evaluation

Use this as a quick internal review template:

1. Data location: Where is data processed and stored?
2. Data flow clarity: Is there a clear diagram or explanation of what leaves Atlassian?
3. Access model: Who can access stored data (vendor staff, support, automation)?
4. Authentication controls: How are API keys/tokens handled and rotated?
5. Encryption: Is data encrypted in transit and at rest?
6. Residency/compliance fit: Does the architecture align with your data residency and policy needs?
7. Retention & deletion: Are retention and deletion mechanisms explicit?
8. Auditability: Can you trace key actions/events for investigation?
9. Incident response: Is there a documented process and communication path?
10. Operational maturity: Are support SLAs and escalation paths clear?

🚀 A practical rollout model for IT and admins

A simple rollout sequence keeps teams moving without skipping diligence:

1. Shortlist by architecture fit (not by features alone)
2. Run the 10-point checklist
3. Pilot with one team/project
4. Collect operational feedback (performance, support responsiveness, admin friction)
5. Scale with a documented approval path

This approach helps avoid expensive rework after procurement or security feedback.

💡 Final takeaway

The best Marketplace app isn't just feature-rich — it's the one your organization can adopt with confidence.

When architecture is aligned from day one, teams spend less time in approval loops and more time creating value inside Jira and Confluence.

If your team is reviewing Atlassian apps this quarter, start with one question:

Where does our data live, and what is the operational risk model?

That single question often saves weeks of back-and-forth later.

🔗 Our Forge-native apps

All Yamuno apps run on Atlassian Forge — no external servers, no data leaving Atlassian infrastructure.

👉 Markdown Exporter & Importer for Confluence

👉 Markdown Renderer for Confluence

👉 LaTeX Math for Confluence

👉 Advanced Attachment Manager for Confluence

👉 Charts, Reports and Graphs for Jira Dashboard

Have questions about our security model or app architecture? Reach out via our support portal — we're happy to answer any review questions your team has.

Every engineering team ends up having this conversation. Notion looks great, feels fast, and your product team is already using it. Confluence is what the rest of the company uses and it connects to Jira. Which one do you actually choose for your engineering docs?

This isn't a feature checklist. It's a practical breakdown of where each tool wins and loses for the specific things engineering teams care about.

Where Notion Wins

Cleaner editing experience

Notion's editor is genuinely better to write in. Slash commands, drag-and-drop blocks, inline databases — it's fast and intuitive. New team members pick it up in minutes without any training.

Confluence's editor has improved significantly but still feels heavier. Formatting can behave unpredictably, especially with tables and code blocks.

Flexible databases

Notion's database feature is genuinely powerful for tracking things like project status, interview notes, incident logs, or sprint retrospectives. You get table, kanban, gallery, and calendar views on the same data.

Confluence doesn't have an equivalent. You can build tables manually, but they're static — no filtering, no views, no relations.

Lighter setup

Notion has no infrastructure to manage. You sign up, create a workspace, and start writing. No spaces, no permission schemes, no schemes at all — just pages and databases.

Where Confluence Wins

Jira integration

If your team uses Jira, Confluence is the clear choice. You can embed live Jira issue lists, link pages to Jira epics, create requirements docs that stay connected to the tickets implementing them, and reference sprints directly from meeting notes.

Notion has a Jira integration but it's surface-level — you can embed issue links, not live filtered views.

Code documentation

Confluence has a proper code macro with syntax highlighting for virtually every language. Code blocks are first-class citizens. For teams writing RFCs, architecture decision records, API docs, or runbooks with embedded scripts, this matters.

Notion's code blocks work but feel like an afterthought — no line numbers, limited language support, no copy-to-clipboard in some views.

Permissions and access control

Confluence has granular space-level and page-level permissions. You can restrict a page to a specific group, make a space public to specific users, and manage access at every level. This matters when your engineering org shares a Confluence instance with legal, HR, or finance.

Notion's permissions are simpler — which is also its weakness. Team plans give you workspace-level controls but page-level restrictions require careful setup and can be easy to misconfigure.

Scale

Confluence handles very large documentation sets better. A 10,000-page knowledge base in Notion becomes slow and hard to navigate. Confluence's space structure, hierarchical pages, and search all hold up at enterprise scale.

Compliance and data residency

For teams in regulated industries, Confluence Cloud offers data residency options and SOC 2 / ISO 27001 certifications. Atlassian's Forge platform means apps built on top of it run on Atlassian's own infrastructure — no data leaving the platform.

Notion has made progress here but is still playing catch-up for enterprise compliance requirements.

The Honest Take

Choose Notion if:

• Your team is small (under 20 engineers)
• You're not using Jira
• You want a lightweight tool with minimal setup
• Your docs are mostly project notes, meeting notes, and knowledge bases — not technical specs

Choose Confluence if:

• You're already on Jira — the integration alone justifies it
• You have a large engineering org with complex permission needs
• You write a lot of code-heavy docs (RFCs, runbooks, API references)
• You're in a regulated industry or need enterprise compliance
• You need your docs to scale to hundreds of pages across many teams

Making Confluence Better for Engineers

Confluence's biggest gap for engineering teams is markdown support. Developers think in markdown — it's what they use in Git, in READMEs, in pull requests. Writing in Confluence's rich text editor feels foreign.

A few apps close this gap significantly:

Markdown Renderer for Confluence — Write pages in raw markdown inside Confluence. Real-time preview, GitHub-flavoured markdown, math support, code highlighting.

Markdown Exporter & Importer — Import your existing markdown files from GitHub or GitLab directly into Confluence. Export pages back to markdown for Git sync.

LaTeX Math for Confluence — For teams doing any kind of mathematical documentation — algorithms, ML models, data science — native LaTeX rendering in Confluence pages.

These don't turn Confluence into Notion. But they do make Confluence feel much more natural for developers who live in markdown and code.

Bottom Line

Notion is the better writing tool. Confluence is the better engineering platform. If you're choosing for a team that already uses Jira and needs to document systems at scale, Confluence is the stronger foundation — especially once you add the right apps to fill in the gaps.

Building on Confluence and want to make it more developer-friendly? Check out our apps for Confluence built specifically for technical teams.

We're thrilled to announce the launch of Charts - Reports and Graphs for Jira Dashboard! This powerful new app transforms your Jira data into beautiful, interactive visualizations that bring clarity to your project insights and team performance.

🌟 What Makes Charts - Reports and Graphs for Jira Dashboard Special

📈 Interactive Charts and Table Views

Visualize your Jira issues with stunning chart types including:

• Bar Charts: Perfect for comparing quantities across categories
• Line Charts: Ideal for tracking trends over time
• Pie Charts: Great for showing proportions and distributions
• Area Charts: Excellent for cumulative data visualization
• Scatter Charts: Useful for correlation analysis
• Dynamic Tables: Detailed data in organized, sortable formats

🎨 Advanced Customization and Branding

Make your charts truly yours with comprehensive branding options:

• Custom Logos: Add your company logo to every chart
• Color Schemes: Choose from preset palettes or create custom colors
• Chart Styling: Adjust opacity, segment order, and axis labels
• Layout Control: Position legends, hide elements, and fine-tune appearance

🔍 Flexible Data Selection

Choose exactly what data to visualize:

• Project Selection: Pick single or multiple projects
• Field Filtering: Focus on specific custom or system fields
• Label Targeting: Include only issues with certain labels
• JQL Queries: Use advanced JQL for precise data filtering

📊 Powerful Grouping and Analysis

Gain deeper insights with flexible grouping options:

• Status Grouping: See issue distribution across workflow states
• Assignee Analysis: Track team member workloads
• Issue Type Breakdown: Analyze task, bug, and feature distributions
• Project Comparison: Compare metrics across multiple projects
• Label Analysis: Group by custom labels for specialized insights

💡 Why Your Team Needs This

Charts for Jira Dashboard solves the challenge of making sense of complex Jira data. Instead of struggling with spreadsheets or static reports, you get:

⚡ Real-Time Insights

• Live data updates directly from your Jira projects
• Interactive dashboards that refresh automatically
• Instant visualization of project changes

🎯 Better Decision Making

• Clear visual patterns in your data
• Quick identification of bottlenecks and trends
• Data-driven insights for sprint planning and resource allocation

👥 Enhanced Team Communication

• Visual reports that everyone can understand
• Branded charts for client presentations
• Shareable dashboards across your organization

🚀 Common Use Cases

Sprint Management

• Sprint Burndown: Track remaining work in current sprints
• Velocity Charts: Monitor team performance over time
• Sprint Health: Identify blockers and risks early

Project Monitoring

• Project Status: Overall health dashboards
• Issue Distribution: Types, priorities, and assignments
• Progress Tracking: Completion rates and timelines

Team Analytics

• Workload Distribution: Balance assignments across team members
• Performance Metrics: Individual and team productivity insights
• Capacity Planning: Resource allocation and sprint planning

🔗 Get Started Today

Ready to transform your Jira data into actionable insights?

👉 Install Charts for Jira Dashboard

Quick Start Guide

1. Install the App: Add Charts gadget to your Jira dashboard
2. Select Data: Choose projects, fields, or labels to visualize
3. Pick Chart Type: Select the visualization that fits your data story
4. Customize: Add your branding and adjust styling
5. Share: Add to dashboards and share with your team

📚 Learn More

Explore our comprehensive documentation to master all features:

👉 Charts for Jira Dashboard Documentation

Need help getting started? Our support team is here to assist you with setup and best practices.

✨ Ready to Visualize Your Success?

Transform scattered Jira data into clear, actionable insights. Whether you're tracking sprint progress, analyzing team performance, or presenting to stakeholders, Charts for Jira Dashboard gives you the tools to tell your data's story.

Start creating beautiful charts today!

Have questions or feedback? We'd love to hear from you via our support portal. Your input helps us continue improving our apps to better serve your team's needs.

Bring order to your Confluence spaces with fast search, powerful filters, and time‑saving bulk actions — all in one place.

✨ Highlights

• 🔍 Advanced filtering: space, page, hierarchy, usage (used/orphaned), type, uploader, date
• 🧹 Bulk actions: delete, download — with safeguards and audit trail
• 🧭 Global dashboard: see and act across spaces from one screen
• 📝 Audit logs: full history of actions for accountability
• 🧷 Orphan detection: find unused attachments instantly
• 🔒 Permission controls: respect Confluence permissions

⚡ How it helps

• Reclaim storage and speed up Confluence
• Save hours otherwise spent searching and cleaning
• Strengthen compliance with clear visibility and logs

👀 See it in action

✅ Try it now

• Marketplace: Advanced Attachment Manager for Confluence
• Docs: Advanced Attachment Manager Documentation

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

Confluence's built-in export gives you HTML or PDF. Neither is portable. Neither fits a docs-as-code workflow. Neither works with Obsidian or a static site generator. For teams that live in both Confluence and Markdown — developers, technical writers, and DevOps teams — that gap has been a constant friction point.

Markdown Exporter for Confluence closes it.

What Is Markdown Exporter for Confluence?

Markdown Exporter is a Forge-native Confluence Cloud app that exports any page, page hierarchy, or entire space to clean, well-structured Markdown — without leaving Confluence and without sending data outside Atlassian's infrastructure.

The output is readable, portable Markdown that works immediately with MkDocs, Docusaurus, Obsidian, GitHub, GitLab, and any tool that understands the format.

Key Features

Single Page, Tree, or Full Space

Export exactly the scope you need:

• Single page — export any Confluence page to a .md file in one click
• Page tree — select a parent page, choose which child pages to include, and download a structured ZIP
• Full space — export an entire Confluence space with the full page hierarchy preserved as folders

Multi-page exports are bundled into a ZIP that mirrors your Confluence structure.

YAML Front Matter

Optionally include YAML front matter at the top of every exported file. Built-in fields include title, author, date, space, and confluence_id — each individually toggleable. You can also define your own custom key-value fields to tag exports for downstream pipelines or static site generators.

Obsidian Wikilinks Mode

Enable Obsidian mode and all internal Confluence page links are automatically converted to [[Page Title]] wikilink format. Drop the export into your Obsidian vault and the links resolve as if they were native notes.

Custom Filename Patterns

Define how your exported files are named using {title}, {date}, and {id} tokens. Useful for building archives where filenames need to be predictable, sortable, or unique.

Live Markdown Preview

Before downloading, preview the rendered Markdown of any page. What you see in the preview is exactly what ends up in the file — no surprises.

In-Tree Search

Search pages by title directly in the export tree with live highlighting. Useful when you're working with large spaces and only need a specific subset of pages.

Runs Entirely on Atlassian Forge

Markdown Exporter is 100% Forge-native. All processing happens inside Atlassian's infrastructure. Exported files are delivered directly to your browser — nothing is stored on external servers.

Who Is It For?

Markdown Exporter is built for teams that need their Confluence content outside Confluence:

• Developers syncing documentation with Git repositories or publishing to static sites
• Technical writers migrating content between platforms or maintaining a backup in a readable format
• DevOps and platform teams building docs-as-code pipelines where Confluence is the editing surface and Git is the source of truth
• Obsidian users who want their team's Confluence knowledge base available as a local, searchable vault
• Anyone running a Confluence migration who needs clean Markdown output as the intermediate format

Getting Started

1. Install the app from the Atlassian Marketplace
2. Open any Confluence page and click ••• (More actions) → Export to Markdown
3. Choose your scope — single page, page tree, or full space
4. Configure options — front matter, filename pattern, Obsidian mode
5. Preview, then export and download your Markdown files

👉 Install Markdown 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.