104 posts tagged with "how-to"

Markdown is the lingua franca of everything Confluence isn't: LLM context windows, RAG pipelines, Git-based docs, static site generators. So the request shows up wherever those worlds meet — "can you get our Confluence into Markdown?" — and the honest answer starts with a gap: Confluence Cloud has no native Markdown export. Built-in export gives you PDF, Word, HTML and XML; Markdown isn't on the list. Here's how to get there anyway, and how to make the output something a pipeline can actually consume.

Every bug report eventually contains the same artifact: a REST response pasted into a Jira comment as one 4,000-character line. Nobody can read it, Jira can't help — the editor has no JSON tooling at all — and the payload gets re-pasted, re-formatted in a browser tool, and re-pasted again until someone gives up. Here are the three workable ways to handle JSON in Jira, from native-and-free to an in-issue panel, and where each one fits.

Jira's announcement banner is the one message every user sees on every page — which makes it the most valuable and most wasted slot in the instance. Most banners fail the same way: too vague ("System update"), too loud ("URGENT!!!! READ THIS"), or left up so long the team stops seeing them. This is a library of banner messages that work, organized by scenario. Copy one, replace the specifics, and ship it in under a minute.

Every team says it has a definition of done. Then you look at a closed ticket: the release notes were never written, one test is skipped, the customer was never told. Jira didn't fail them — Jira never knew what "done" meant. The Done button closes anything. This post gives you a copy-paste definition of done template for stories and bugs, shows where to store it so it's actually on every ticket, and walks through the enforcement options from free to fully gated.

The API spec always ends up in Confluence eventually — the review page, the integration guide, the "what does this endpoint return" discussion. And Confluence does nothing with it: paste an OpenAPI YAML into a code block and you get monospaced text that scrolls for forty screens. No endpoint tree, no expandable examples, no way to see what a 200 response looks like without reading the schema by eye. Here are the three realistic ways to get a spec onto a Confluence page, ending with the one that renders it as actual API documentation.

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

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

The migration is done. Pages moved, spaces are there, the site is live and people are using it. Then someone clicks a link in an onboarding page and lands on a 404 that points at jira.mycompany.com — a hostname that stopped answering the day you cut over.

It is a common post-migration complaint, and it has a specific cause worth understanding, because the fix is different depending on where the link is.

A Confluence instance does not rot all at once. It accumulates. A project wraps up and its space stays. A team splits and both halves keep the old runbook. Someone copies a page instead of linking to it, and now two versions exist with different numbers in them. Five years later a new hire searches for the onboarding doc, lands on the 2021 version, and trusts it.

The cleanup instinct is right. The problem is that "find stale pages" is one of those tasks where the answer depends entirely on which Confluence plan you happen to be on, and almost nobody knows that until they go looking. Here is what each tier actually gives you, in the order you should try it.

Jira configuration does not rot the way Confluence content does — nobody notices a redundant workflow scheme on a page. It shows up as slowness. Atlassian's own cleanup guidance notes that too many custom fields can clutter an instance and affect its performance, and that every field is evaluated during create, update and index operations.

The hunt is the easy part, once you know which tool applies to you. The awkward part is that Atlassian gates its site-wide cleanup tooling to the top two plans — and the free fallback doesn't fully cover the gap.

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

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

A 4,000-word runbook. A 300-row release checklist. A training doc with five chapters. Sooner or later every Confluence space hits the wall: the page that takes forever to scroll, buries the section the reader needs, and times out in the editor when someone tries to reorganize it. Pagination is the standard fix everywhere else on the web — and Confluence doesn't have it, a gap the community has flagged since 2018. Here's what actually works instead.

The diagrams live in the repository. They were written in Mermaid, they are reviewed in pull requests next to the code they describe, and they are correct as of the last commit. The documentation, however, lives in Confluence — because that is where the rest of the team reads it. So somebody copies a Markdown file across, pastes it into a Confluence page, and the flowcharts, sequence diagrams and ER models arrive as grey boxes of unrendered code.

Everyone has hit this. It is one of the most common Confluence complaints, and the usual workarounds are worse than the problem: export every diagram to PNG and re-upload them (now they rot), keep the diagrams in an external tool and paste links (readers need a second account, and the links break), or build a browser extension to force rendering on paste.

There is a better answer, and Mermaid 12 makes it better still.

Every team has Markdown lying around that Confluence needs: the README that became the service doc, the design doc drafted as a pull-request description, the runbook that lives in the repo. And every attempt to move it hits the same wall — Confluence's default editor does not parse Markdown. Paste a .md document and you get a wall of pipes, backticks, and asterisks that looks exactly like what it is: text nobody formatted.

The macro route dissolves the wall. Paste the document into a Markdown macro that actually parses it, watch it render in the preview pane, publish. This page is the workflow, end to end.

Every engineering page in Confluence eventually holds code — a curl from the runbook, the config that fixed the incident, the query the dashboard runs. And every one of those snippets has three natural enemies: the language dropdown in the macro dialog, the paste that loses its indentation, and the reader who cannot copy the thing without dragging across line numbers.

Markdown fences solve all three, because they make the code block text you type instead of an object you configure. ```bash, paste, ``` — done, highlighted, copyable. This guide shows the syntax, the theming behavior, and when fences beat the native macro.

Ask an engineer to document an algorithm in Confluence and watch what happens to the math: O(n log n) typed as plain text, x² pasted from a character map, and — for anything real — a screenshot from an online equation editor, blurry and already out of date. Confluence has no native LaTeX support, so every formula becomes either a compromise or an image.

It does not have to. With a Markdown macro on the page, Confluence renders real LaTeX — inline $...$, display $$...$$, fenced blocks with full align environments — and the equation stays text: searchable, theme-consistent, editable in seconds. This guide gives you the syntax and copy-paste examples for all three routes.

Meeting notes fail in one of two directions: they are so informal that nobody can find the decision a month later, or so formal that nobody takes them at all. The Confluence editor quietly encourages the second — formatting dialogs are the enemy of live note-taking.

Markdown flips it. In a split-pane editor, notes are keystrokes: two characters for a heading, pipes for a table row, backticks for a snippet — and the rendered page assembles itself in the right pane while you type. This guide ships the template and the habits that make notes pages worth opening later.

The integration doc says "the client calls the API, the API validates and responds" — four words, zero contracts, and the onboarding engineer asks "with what headers, in what order, and what if auth fails?" The code has the truth; the wiki has a paragraph. An API that can't be read as a transcript is an API nobody can safely operate.

Quick answer: document API flows in Confluence as Mermaid — sequenceDiagram for request/response order, packet-beta for wire-format frames, ZenUML for branch-heavy async flows — rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Each diagram type answers a different reader: what order, what's on the wire, what branches. This post gives you three copy-paste examples.

The onboarding doc says "check the architecture diagram" and the architecture diagram shows a monolith from 2023 that the team decommissioned in the spring. Nobody is lying — the draw.io file lives on one person's laptop, and the wiki holds a screenshot nobody owns. An architecture that only exists as a static export rots silently, because the thing you would edit is invisible to review.

Quick answer: document system architecture in Confluence as Mermaid text — C4Context for the system in context, architecture-beta for the deployment, block-beta for the topology you want laid out precisely — rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Every level stays an editable code block, so the wiki's architecture changes in the same review that changes the system. This post gives you three copy-paste examples.

The quarterly review loads a 14-tab spreadsheet to answer one question — "where do we actually spend our engineering time?" — because the wiki charts are stale screenshots from last quarter and the numbers table nobody reads. A dashboard is not a spreadsheet: it is the two charts that answer the two questions people keep asking.

Quick answer: build dashboard charts in Confluence with Mermaid pie and xychart-beta charts, rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Pie for shares, XY for trends — both as editable text that refreshes like code. This post gives you three copy-paste examples: an effort-share pie, a weekly trend XY, and a dual-series release dashboard.

A build fails at 4pm, and the fix's pipeline takes 40 minutes to re-run from the top because someone decided every stage needs to re-validate. That wasted hour is not a code problem — it is a documentation problem. Nobody could see the pipeline's shape, so nobody saw the retry loop and the gate that would have caught the failure three stages earlier.

Quick answer: put the pipeline's shape in Confluence as a Mermaid flowchart, rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Text-based, editable, diffable — a pipeline diagram that changes when your pipeline changes. This post gives you three copy-paste examples: the linear stage view, quality gates with retry loops, and the deploy-to-tag gitGraph that records what actually shipped.

Your team grows by two people. The new hires open the wiki and find the architecture doc: a screenshot of a whiteboard, dated 14 months ago, where PaymentService does everything except the thing the diagram says OrderService does. Day-1 onboarding just taught two people the wrong architecture.

Quick answer: keep the architecture in Confluence as a Mermaid class diagram, rendered by Mermaid Plus Diagrams & AI Agent for Confluence and diffs like code. Classes, methods, interfaces, ownership — in editable text that updates when the code does. This post gives you three copy-paste examples: the onboarding service map, interface+implementation modules, and a request-flow sketch.

The meeting asks "who owns this feature?" and the answer is a Venn diagram by hand — drawn on a whiteboard, erased, redrawn, photographed, and lost. Two teams each built a piece of a shared workflow, and "the overlap" is exactly where the bugs and the SQL both landed. A decision framework is only useful while its picture survives the meeting; in Confluence as Mermaid text, it survives.

Quick answer: put decision frameworks in Confluence as Mermaid — venn-beta for set overlap, cynefin-beta for which operating mode a situation needs, quadrantChart for which item goes first — rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Each framework encodes a decision shape, and text keeps the picture attached to the decision record. This post gives you three copy-paste examples.

The bug report says "orders show twice in the report" and the fix takes three days because nobody on the team is sure whether order_lines links to orders on order_id or source_order_id, and both columns exist. The schema is documented — in a schema.md that lists columns as bullets and a diagram that was last exported when the DB was two migrations younger. The join question is exactly the thing an ER diagram answers at a glance, and the thing a bulleted column list cannot answer at all.

Quick answer: document the database schema in Confluence as a Mermaid erDiagram, rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Entities hold keys and attributes; relationship lines carry the cardinality and the join's noun. When the discussion turns to the domain model the code exposes, add a classDiagram on the same page. This post gives you three copy-paste examples.

A root cause analysis is only as good as the disagreement it survives. When the 'root cause' box on your postmortem template contains one sentence, the meeting spends an hour relitigating that sentence. A fishbone diagram and a 5 Whys chain move the argument onto a diagram: everyone sees which categories were considered, which branch was chosen, and exactly how the 'why' answers arrive at a root cause.

Confluence is where RCA already happens — in the Root Cause Analysis template, in postmortems, in retros. The missing piece is a diagram that holds the reasoning. This guide shows you two copy-paste Mermaid diagrams: an ishikawa fishbone that maps every candidate cause category, and a flowchart 5-Whys drilldown that lands on one concrete fix.

Your team is mid-debug on a prod incident. A senior engineer asks "which release shipped this commit, and why is it on the release branch when the PR said main?" — and nobody can answer without switching between Jira, the git web UI, and a Slack thread. That context — commit history, branches, merge points, release versions — belongs next to the issue, not in a tool people have to leave Jira to open.

Quick answer: paste a Mermaid gitGraph into the issue's Mermaid Plus Diagrams for Jira panel and the branch history renders as a diagram right on the ticket — commits, branches, merges, and release tags, all in one editable text block. This post gives you three copy-paste examples: a trunk-based feature workflow, a hotfix outside the release window, and a branch-rule flowchart to keep behavior consistent.

Every incident has a story hidden inside a pile of timestamps: alert fired at 09:42, nobody acknowledged until 09:47, an engineer escalated at 09:54, a workaround landed at 10:20, services healthy at 10:31. Individually the timestamps mean nothing. Laid out on a timeline, they tell the story — and the story is what a postmortem is for.

Confluence is where incident postmortems already live. What Confluence does not give you is a native timeline. This guide shows you how to fill the Timeline section of an incident postmortem with a Mermaid diagram: one copy-paste timeline that visualizes detection → escalation → resolution, plus a sequence diagram that shows exactly how the failure propagated between services.

The support team knows where refunds leak. The product team knows where onboarding drops. The sales team knows where the pricing page confuses. Three silos, three versions of the customer's experience — and the roadmap meeting spends an hour reconciling them instead of deciding what to fix. What is missing is a single picture with a score on every step.

Quick answer: draw customer journeys in Confluence as Mermaid journey diagrams, rendered by Mermaid Plus Diagrams & AI Agent for Confluence. A journey diagram puts every step in a row and every satisfaction score on one curve — the dips are visible, the actors are labeled, and the whole thing stays editable text. This post gives you three copy-paste examples: onboarding, a support ticket, and a checkout flow with a summary pie.

The sprint board on the wall shows 40 items in "In Progress" and the rulebook says "we limit WIP" and nobody agrees on what the limit is. The board is honest; the documentation is aspirational. A Kanban diagram in the wiki is the board as a spec — columns, limits, and the rework paths drawn so the workflow is a claim the team can argue with.

Quick answer: document the team's board in Confluence as a Mermaid kanban, rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Columns as headings, work items as indented cards; the workflow rules (who may move what, when, including rework) as a stateDiagram on the same page. This post gives you three copy-paste examples.

The kickoff note is 40 lines of indented bullets with three levels of bolded sub-points, and half the room is still asking "so what are we actually deciding today?" The other half is screenshotting a mind map someone whiteboarded in five minutes. The whiteboard died at cleanup; the bullets survived but nobody can navigate them. A mind map is the readable version of nested notes — and when it lives in Confluence as Mermaid text, it survives the meeting.

Quick answer: turn nested notes into a Mermaid mindmap in Confluence, rendered by Mermaid Plus Diagrams & AI Agent for Confluence. The indented text you already write becomes the branches; for concrete structures — folder layouts, project trees — use treeView; when item size matters and you want area instead of lines, use treemap. This post gives you three copy-paste examples.

The ticket sits in "Waiting on customer" for a week and nobody noticed, because the handoff between first-line support and the dev team is a tacit step: Support marks it "escalated" in one field, Engineering is supposed to watch a filter, and the transfer never surfaces as its own action. That inert weekend is a process bug, and the fix is to see the handoff. A swimlane diagram makes the ownership transfer its own crossing arrow — invisible to everyone until it is drawn.

Quick answer: map cross-functional processes in Confluence as Mermaid swimlane-beta, rendered by Mermaid Plus Diagrams & AI Agent for Confluence. One lane per actor, steps sequenced inside lanes, and the handoff is the arrow that crosses a lane boundary. When the interaction is a short request/response instead of long-running work, switch to a sequenceDiagram. This post gives you three copy-paste examples.

The team page says "we own the checkout" and the skills tab lists four words nobody updated. When the sprint needs a React engineer, the wiki can't say who is nearest. Meanwhile, the contributor guide links to a repo whose shape is a mystery ship in a fog of folders. Structure and capability both want drawing — and both draw from plain text.

Quick answer: track capabilities and structure in Confluence as Mermaid — radar-beta for multi-axis comparison across profiles, treeView-beta for repo and structure maps, railroad-ebnf-beta for syntax and grammar diagrams — rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Each chart answers a different "what's the shape": of the team, of the repo, of the language. This post gives you three copy-paste examples.

The feature ships with a test suite that validates four scenarios. The PRD lists seven requirements. The compliance review asks "which requirement is the encryption actually in scope for?" — and the answer is a spreadsheet cross-referenced by color, maintained by one person, last updated before the sprint began. Traceability does not scale as a spreadsheet; it scales as a diagram that is the trace.

Quick answer: document requirements traceability in Confluence as Mermaid requirementDiagram, rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Each requirement connects to the elements that satisfy and verify it — the gaps read at a glance, and the whole thing stays editable text next to the PRD. This post gives you three copy-paste examples: a feature trace, a compliance control, and an epic-to-test gap review.

The quarter plan is a spreadsheet with thirty rows, color-coded by priority, sorted by a column half the team doesn't trust. The kickoff asks "what are we doing when — and why this first?" and the answer requires parsing three tabs. Planning outputs are shapes: schedules stack as bars, priorities sit on a 2x2, flows bundle as ribbons. The spreadsheet stores them poorly; Mermaid draws them as text.

Quick answer: put the quarter plan in Confluence as Mermaid — gantt for when things happen, quadrantChart for which gets built first, sankey-beta for where the budget goes — rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Three charts, three planning questions, one editable page. This post gives you three copy-paste examples.

The issue workflow lives in a wiki page that says "the approval chain is: team lead, then manager, then finance". The config says otherwise, the Jira post-function disagrees, and the incident report asks "who actually approved this?" — with three different answers on screen. A prose paragraph cannot hold a workflow; a diagram can, if it is the workflow.

Quick answer: document state machines and approval chains in Confluence as Mermaid stateDiagram-v2, rendered by Mermaid Plus Diagrams & AI Agent for Confluence. Every legal state, every transition, every human decision on a labeled arrow — in editable text that stays true. This post gives you three copy-paste examples: an issue lifecycle, a spending approval chain, and a retry loop with a timeout.

The use case diagram is the scope picture: actors on the outside, what the system does for them on the inside, and — the reason product and engineering fight — the line between them. In Confluence that picture usually comes from a diagramming tool export that goes stale the moment scope moves.

Mermaid 12 added the syntax to render UML use case diagrams from text — usecase-beta — and Enhanced Markdown for Confluence renders it in the same macro as everything else on the page. This guide gives you the syntax and two copy-paste diagrams.

Sequence diagrams die in Confluence in one of two ways: someone draws one in a diagramming tool, exports a PNG, pastes it into a page — and three sprints later the flow has changed but the image has not. Or someone writes the flow as prose ("the client calls the order service, and if payment is approved…"), which is accurate but impossible to read under time pressure.

ZenUML splits the difference: the diagram is code, so it edits like code and renders like a diagram — branches, error paths, and parallel work included. This guide shows the syntax with copy-paste examples you can drop into Confluence today.

Every Confluence page has two faces: the one you see in the editor, and the one the database sees. The database face is the storage format — an XHTML document with macros as tags — and before it, Confluence stored pages as wiki markup: h1. headings, *bold text*, {code} blocks. People still search for wiki markup because half the internet's Confluence advice, every migration script, and a lot of content written before ~2017 speaks that language. And in 2026 the topic got urgent: Atlassian is retiring the legacy editor (full deprecation April 2026), and the new cloud editor dropped the Markup macro entirely. Here's how to view, edit, and convert what's actually stored — with or without admin rights.

Jira components were designed for a flat world: one list, no nesting, no structure. That works at ten components and collapses at fifty — when "SSO" sits next to "Platform" and "Mobile" with nothing expressing that it belongs under "Auth", which belongs under "Platform". Teams end up encoding the architecture in name prefixes and maintaining ever-growing component in (...) lists by hand. This guide covers three ways to get a component hierarchy in Jira, and what each one costs.

Every Jira issue keeps a diary. Status flips, priority bumps, reassignments, edited specs — Jira writes all of it down. The problem is reading it back: the built-in history turns a description edit into one unhelpful line, and "who changed this?" across forty issues becomes forty clicks or a REST script. This guide covers three ways to actually read Jira issue history, from the free built-in tab to field-level diffs and a cross-issue CSV report.

Every team has a definition of done. The problem is that in Jira, "done" is one button press — nothing checks whether the release notes were written, the tests passed, or the customer was notified. A checklist fixes the remembering; enforcement fixes the skipping. This guide covers three ways to add a checklist to Jira issues, from a two-minute bullet list to required items that physically block the Done transition.

Half the debugging in a Jira-integrated stack ends at the same place: a wall of braces. A webhook payload pasted into a comment, a config blob in a custom field, entity properties an integration app quietly wrote onto the ticket — the JSON is there, on the issue, but reading it means scrolling and counting brackets. Here are three ways to actually read it, from free-but-painful to a proper graph view inside Jira.

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

Jira is where the work happens — but the process behind the work usually lives in someone's head or in a stale Confluence page nobody opens. A flowchart on the Jira issue itself fixes that: bug triage paths, approval chains, and escalation procedures become visual, unambiguous, and impossible to miss.

Jira Cloud gives you two ways to get there, and they serve different needs. This guide walks through both, then gives you three copy-paste Mermaid flowchart examples for the scenarios Jira teams hit most: bug triage, approval workflows, and incident escalation.

A release date doesn't slip in one dramatic moment — it slips in six quiet ones: QA took two extra days, staging froze late, sign-off waited on legal. A release timeline pinned to the release epic makes those slips visible while they're still cheap to fix, because every stakeholder reads the same picture of what's next and what's blocked.

Jira gives you three ways to build that picture. This guide walks through them, then gives three copy-paste Mermaid Gantt examples sized for real releases: a single version, a multi-team launch, and a launch-week sequence.

Long pages die from scroll fatigue. Onboarding checklists, troubleshooting trees, API reference details, legal disclaimers — content that only some readers need some of the time is the canonical use case for collapsible sections. Confluence ships a native expand macro for exactly this, and for many pages it's enough.

This guide covers how the native expand works, where teams typically outgrow it, and what a styled accordion macro adds — so you can pick per page, not per vendor.

Tabs are the layout workhorse of product pages, API references, and comparison docs: they let one page hold three versions of the truth (per environment, per plan, per language) without tripling the scroll length. Confluence's answer to tabs has changed over the years, so this page sorts out what exists today and which to use when.

Developers, technical writers, and data scientists think in Markdown. READMEs, API docs, pull request descriptions, and design specs are all written in it. But Confluence — where most of that knowledge ends up living — has no native Markdown support. Pasting Markdown into the WYSIWYG editor produces broken tables, literal asterisks, and lost formatting. This guide walks through the options so you can pick the right Markdown approach for your team without trial and error.

Take a look at your most-visited Confluence page right now. Does it look like it belongs on the modern web — or does it look like internal documentation from 2015?

If your answer is the latter, you're not alone. Teams across thousands of Confluence sites tell us the same story: "I know exactly what I want my page to look like. I just can't make Confluence do it."

In this guide, we'll show you six concrete ways to level up your Confluence pages — from Medium-style reading layouts to interactive surveys — all without leaving your editor.

Code reviews happen in pull requests, but the decisions and context often get lost. When someone asks "why did we implement it this way?" the answer is buried in a closed PR with hundreds of comments.

Documenting code reviews in Confluence preserves this context. AI can automate the documentation, turning unstructured PR discussions into organized knowledge. This guide covers how to use AI for code review documentation.

Documentation quality degrades over time. Pages get outdated, formats drift, and gaps emerge as the team and product evolve. Manual review is time-consuming and often inconsistent.

AI can automate documentation review, identifying quality issues and improvement opportunities at scale. This guide covers how to use AI for Confluence documentation review, from audits to automated reports.

Sprint planning is part science, part guesswork. Teams estimate velocity based on gut feeling, leading to overcommitment or underutilization. AI can replace this guesswork with data-driven predictions.

This guide covers how to use AI for Jira sprint planning, from velocity prediction to scope recommendations.

Every new Jira issue needs decisions: What type is it? Who should work on it? How urgent is it? These decisions happen manually today, taking time and introducing inconsistency.

AI can automate these decisions by analyzing issue content, historical patterns, and team context. This guide covers how to use AI for Jira workflow automation, from triage to assignment.

Meetings are where decisions get made, but the notes rarely get written. Someone volunteers to take notes, gets distracted by the conversation, and the team leaves with fragmented memories and no clear action items.

AI meeting notes solve this by automatically capturing, transcribing, and summarizing meetings. This guide covers how to set up AI meeting notes in Confluence, from transcription to follow-up.

Confluence search is powerful but often frustrating. You know the information exists, but your search queries don't find it. Keywords miss synonyms, related content uses different terminology, and results bury the answer under irrelevant pages.

AI-powered search fixes this by understanding intent instead of just matching keywords. This guide covers how to use and optimize AI search in Confluence.

Teams waste hours searching Confluence for answers that already exist. A chatbot can bridge this gap by providing instant answers from your knowledge base, right where the team works.

This guide covers how to build an AI chatbot for Confluence, from no-code solutions to custom development.

Writing good documentation takes time. Between drafting, editing, formatting, and organizing, creating a single Confluence page can take hours. For teams with dozens of pages to maintain, this time adds up quickly.

AI tools like ChatGPT can accelerate every stage of the documentation workflow — from initial drafts to final polish. This guide covers how to use AI in Confluence, from native features to third-party integrations.

Your team has hundreds of Confluence pages, but finding the right information still takes too long. Search returns too many results, keywords miss synonyms, and context gets lost across pages.

RAG (Retrieval-Augmented Generation) changes this by combining search with AI generation. Instead of returning pages, it returns answers — synthesized from your Confluence content. This guide covers how to build a RAG system with Confluence.

The quality of a Jira ticket determines how quickly work gets done. A vague description like "fix the login bug" creates hours of back-and-forth. A detailed description with acceptance criteria, edge cases, and technical context lets developers start immediately.

AI can transform brief summaries into comprehensive tickets. This guide covers how to use AI to write better Jira descriptions, from prompt templates to review workflows.

Inconsistent issue reporting is a silent productivity killer. One developer writes a two-line bug report with no steps to reproduce. Another writes a three-paragraph feature request buried in technical jargon. The result: wasted time clarifying, misestimated work, and frustrated teams.

Issue templates solve this by standardizing how work is described. Every bug report has the same structure. Every feature request includes the same fields. This guide shows how to create and enforce templates in Jira.

Audit logs are the paper trail of your Jira instance. They record who did what, when, and where — essential information for compliance audits, security investigations, and change management.

Without proper audit logging, you cannot prove who deleted that issue, when permissions changed, or whether someone accessed restricted data. This guide covers how to access, export, and analyze Jira audit logs.

Jira's built-in reports are useful, but stakeholders often want data in Excel. Whether it is a weekly status report, a velocity trend analysis, or a custom dashboard, Excel gives you full control over how Jira data is presented.

This guide covers how to export Jira issues to Excel and CSV, from simple one-click exports to scheduled automated reports.

A messy backlog is the silent killer of Agile teams. Stories pile up without refinement, acceptance criteria are vague, and sprint planning becomes a guessing game. By the time the team realizes the backlog is broken, velocity has dropped and trust in the process has eroded.

Backlog grooming — also called refinement — is the antidote. It is the ongoing process of reviewing, splitting, estimating, and prioritizing stories so the backlog is always sprint-ready.

This guide covers a complete grooming workflow in Jira, from writing acceptance criteria to ranking by business value.

A well-designed Jira dashboard gives your team instant visibility into sprint health, backlog status, and delivery trends. But most dashboards are either empty defaults or cluttered messes that nobody uses.

This guide covers how to build dashboards that actually provide value — from sprint tracking to stakeholder reporting.

Jira's search is powerful, but most teams only scratch the surface. They type a few keywords into the search bar, get overwhelmed by results, and give up. JQL — Jira Query Language — is the key to unlocking precise, repeatable searches that find exactly what you need.

This cheat sheet covers 20 essential JQL queries, from basic field searches to advanced functions. Each query is copy-paste ready.

Permissions in Jira control who can do what. Without proper configuration, either everyone can see everything (security risk) or the permissions are so locked down that work stops (productivity risk).

The key is finding the balance: enough access for people to do their jobs, not so much that sensitive data is exposed. This guide covers how to configure Jira permissions without breaking workflows.

Every Jira team has repetitive tasks: assigning bugs to the QA lead, transitioning issues when a pull request is merged, sending notifications when a sprint starts. These tasks follow consistent rules, which makes them perfect for automation.

Jira's built-in automation engine lets you create rules without code. This guide covers how to identify automation candidates, build rules, and scale them across your organization.

Sprint planning is where most Agile teams either build momentum or lose it. A poorly run planning meeting produces a sprint full of half-finished stories, scope creep, and a team that stops trusting the process.

The problem is not Jira itself — it is how teams use Jira during planning. Without a structured workflow, the backlog becomes a dumping ground, story points become guesswork, and the sprint goal vanishes by Wednesday.

This guide walks through a complete sprint planning workflow in Jira, from backlog grooming to daily tracking, so your team ships predictably every two weeks.

The scenario every documentation team hits: you're writing a policy doc or technical spec in Confluence, and it needs numbered sections — 1. Introduction, 1.1 Overview, 1.2 Getting Started, 2. Configuration. So you type the numbers manually into each heading. Then product changes the structure: a section moves up, a new one gets inserted in the middle, and now every number below the change is wrong. You spend twenty minutes renumbering by hand, miss one, and the doc ships with 1.2 followed by 1.4.

Confluence has no native heading-numbering feature. Headings are just styled text — there's no automatic 1.1 / 1.2 scheme. Modern Numbered Headings for Confluence fixes this by generating numbered headings automatically from your H1-H6 structure, with a live preview and five numbering styles. When you reorder sections, the numbers update. This guide walks through setting it up.

The scenario every Jira team hits: a new bug comes in, and the reporter writes "it's broken" with no steps to reproduce, no environment, no severity. Or an incident gets logged without the services-affected checklist. You write a Confluence page titled "How to file a good bug," link to it from the project home, and nobody reads it. The tickets keep coming in malformed.

The real fix is to put the template on the ticket — so the moment someone opens Create Issue for a bug, the description already has the "Steps to reproduce / Expected / Actual / Environment" structure, the right labels, and the right assignee. That's per-issue templating, and Modern Issue Templates for Jira does exactly that. This guide covers three ways to create issues from templates, from quickest to most customized.

The scenario every engineering team hits: you're documenting an API in Confluence, and the page needs to show a JSON response, an XML config, a YAML deployment manifest, and a SQL query — all on the same page. You paste each one into Confluence's built-in code block macro, publish, and the result is a wall of monochrome text. No syntax colors. No line numbers that work. JSON braces, XML tags, and YAML indentation all blur together. The reader has to copy-paste your snippet into VS Code just to understand it.

The root problem is that Confluence's native code block uses a basic highlighter that wasn't built for the structured data formats modern teams actually work with. JSON, XML, YAML, and SQL each have specific visual conventions — matched braces, nested tags, indentation scopes — that a generic highlighter doesn't handle well.

Modern Code Blocks for Confluence solves this by bringing the Monaco Editor — the same engine that powers VS Code — into Confluence. It accurately highlights 85+ languages including JSON, XML, YAML, SQL, GraphQL, Terraform, Dockerfile, and every mainstream programming language. This guide walks through embedding formatted code and data formats in your Confluence pages.

Most Confluence users never see it, but every page is stored as an XML document in Confluence's storage format — a specific XHTML dialect with custom tags for macros, layouts, and embeddings. The visual editor hides this. But sometimes the only way to fix a problem is to edit that XML directly: a macro is corrupted and won't render, a copy-paste introduced broken formatting, or you need to find-and-replace a URL across a long page that the visual editor can't reach.

Confluence exposes the storage format through its REST API, but there's no built-in visual editor for it. Raw Storage Source Editor for Confluence adds one — a Monaco-powered editor that opens the raw storage XML of any page, with format, find-and-replace, and (in the Pro edition) a diff view. This guide covers when and how to use it safely.

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

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

The scenario every Jira admin hits: there's a maintenance window Saturday night, a security policy change, or an ongoing incident — and you need every person who opens Jira to see it immediately. Jira has a built-in announcement banner, but it's plain-text only, lives in a buried admin setting, and gives you one banner at a time with no library, no scheduling, and no way to let users dismiss it.

Modern Announcement Banner for Jira fixes this: rich-text banners with emojis and custom colors, a dismissible option, a saved library of announcements you can switch between with one click, and instant enable/disable without deleting. This guide walks through setting it up.

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

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

The scenario every technical team hits: your engineering docs live in Markdown — READMEs, API references, design docs — and they contain diagrams (Mermaid), equations (LaTeX), and code samples. You paste that Markdown into Confluence, and it falls apart. The Mermaid code blocks render as plain text. The LaTeX equations show as raw $...$ syntax. The code blocks lose their syntax highlighting. Confluence's native editor is WYSIWYG, not Markdown, and the import tools treat Markdown as a one-time conversion rather than something you edit live.

Enhanced Markdown for Confluence solves this with a Markdown editor that renders everything inline — Mermaid diagrams, KaTeX and LaTeX math, syntax-highlighted code, and GitHub-flavored tables — with a live split preview. It runs on the Quikdown engine, so all rendering libraries are bundled locally (no external CDN dependencies, which matters for "Runs on Atlassian" compliance). This guide walks through writing Markdown in Confluence with diagrams, math, and code all rendering live.

FAQ pages are one of the most visited sections of any documentation site. In Confluence, they serve a specific purpose: giving your team or customers quick answers to the questions they ask most often, without making them read through pages of documentation. A well-structured FAQ page reduces repetitive questions in Slack channels, shortens onboarding time for new team members, and deflects support tickets before they are created.

But Confluence does not have a built-in FAQ feature. Teams typically resort to manual workarounds — tables, toggle macros, or expand sections — that look cluttered and are hard to maintain. This guide shows you three methods to create professional FAQ pages in Confluence, from a quick manual setup to a fully featured FAQ macro.

Announcement banners are the most visible communication channel in Atlassian products. They sit at the top of every page, impossible to miss. When you need to notify your entire organization about a maintenance window, a security alert, a policy change, or an upcoming event, banners guarantee visibility in a way that emails and Slack messages cannot.

Both Confluence and Jira support announcement banners, but their native implementations are limited. This guide covers how to set up banners in both platforms using built-in features and marketplace apps, with practical tips for getting the most out of them.

Custom fonts in Confluence let you apply brand typography to your documentation. This guide covers Google Fonts for Confluence — 1,942+ font families, live preview, dark mode support, and customization options.

Google Fonts for Confluence gives you access to over 1,942 Google Fonts directly inside your Confluence pages. You can customize font family, weight, size, color, and alignment with a live preview that shows exactly how your text will look before you save. This step-by-step tutorial walks through everything: installing the app, configuring fonts, applying them across spaces, and maintaining a consistent typographic system that respects accessibility and brand standards.

Adding illustrations to Confluence pages transforms flat walls of text into engaging, professional content. Whether you are writing onboarding documentation, putting together a team wiki, or preparing a presentation, the right visual can communicate an idea faster than a paragraph of explanation. The challenge has always been finding high-quality illustrations that look good at any size, load quickly, and match your team's visual style.

SVG (Scalable Vector Graphics) illustrations solve all of these problems. They scale perfectly to any resolution, they are lightweight, and they integrate cleanly into Confluence pages. Content Craft for Confluence brings a curated library of SVG illustrations directly into the Confluence editor, so you can browse, search, and insert professional illustrations without leaving your workflow.

This tutorial shows you exactly how to add SVG illustrations to Confluence pages using Content Craft for Confluence. By the end, you will be able to transform any Confluence page from text-heavy to visually engaging in under a minute.

FAQ sections are one of the most practical elements you can add to a Confluence page. Whether you are documenting product details, building an IT help desk resource, or writing an onboarding guide, a well-structured FAQ section lets readers find answers without scrolling through walls of text or pinging someone on Slack.

The problem is that Confluence does not give you a built-in way to create FAQ sections. Teams typically resort to manual workarounds: bullet lists, tables, or toggles built from expand macros. These methods work, sort of, but they are tedious to maintain, hard to reorder, and look inconsistent from page to page.

Modern FAQ for Confluence solves this by giving you a dedicated macro for building FAQ sections with drag-and-drop reordering, WYSIWYG editing, and two display themes. This guide walks through the entire process, provides ready-to-use templates, and shares best practices so your FAQ pages actually help people find what they need.

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

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

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

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

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

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

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

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

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

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

Every team that uses Jira long enough runs into the same problem: inconsistent tickets. One developer files a detailed bug report with reproduction steps, environment details, and screenshots. Another submits a two-line summary with no context. Product managers write user stories that vary wildly in structure, making backlog grooming slower than it needs to be. Support teams log incidents using different formats depending on who is on shift. These inconsistencies compound over time and erode the reliability of your Jira data, making reports unreliable and sprint planning harder than necessary.

Issue templates solve this by standardizing the structure and content of every new ticket. When you create a Jira issue template, every bug report follows the same format, every user story has the same sections, and every task includes the same checklists. The result is faster ticket creation, better reporting, and a shared understanding of what "done" looks like across the team.

Mathematical concepts are inherently dynamic. A limit converges, a derivative emerges from shrinking secant lines, a matrix transformation rotates a vector through space. Static screenshots and LaTeX formulas capture the result but miss the process -- and for many students and colleagues, the process is where understanding lives. Animations bridge that gap. They show how equations transform, how geometric constructions unfold step by step, and how abstract algebra connects to visual intuition.

Until recently, embedding math animations in documentation required a multi-tool workflow: write Python scripts with Manim, render MP4 files locally, upload them as attachments or embed them via external hosting, and hope nobody asked you to update them. Manim for Confluence eliminates that entire pipeline. You write animation code directly inside a Confluence macro, and the animation plays inline on the published page -- no file exports, no external hosting, no broken links when the video expires.

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

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

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

Pie charts are one of the simplest and most effective ways to communicate proportional data. Whether you are reporting survey results, breaking down a project budget, or showing how your team allocates time across activities, a pie chart turns a list of numbers into a visual that anyone can read in seconds. Confluence is where your team already stores reports, retrospectives, and planning documents, so embedding pie charts directly on those pages keeps your data alongside the context that explains it.

With Mermaid Plus Diagrams & AI Agent for Confluence, you can create pie charts and other data visualizations using plain text syntax. No image exports, no spreadsheet screenshots, no broken attachments. You write the code once, and the chart renders directly on the Confluence page, updating whenever you edit the underlying data.

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

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

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

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

Wireframes are the backbone of every user interface design process. They let product managers, designers, and engineers align on layout, content hierarchy, and interaction flow before writing a single line of code. With Excalidraw Plus for Confluence, you can create wireframes and UI mockups directly inside your Confluence pages, keeping design artifacts next to requirements, user stories, and technical specs.

Migrating Confluence content is something most teams eventually face. Whether you are moving from Confluence Server to Cloud, reorganizing spaces after a company merger, or splitting a monolithic workspace into focused team spaces, the process can feel overwhelming. Pages link to each other, attachments sit deep in page trees, permissions are inherited from parent spaces, and macros pull data from external sources.

This guide walks through the entire Confluence content migration process from start to finish. You will learn how to plan your migration, choose the right tools for your scenario, export and import content without losing data, and validate the result. We cover both Atlassian's built-in export features and the Modern Importer Exporter for Confluence app for format-based migrations.

If you have ever written a long Confluence page — a technical specification, an SOP, a project charter, or an onboarding guide — you know the problem. You add headings, rearrange sections, insert a new subsection, and suddenly every manual number is wrong. "Section 3.2" becomes "Section 4.2" because you added a new section above it, and you spend the next twenty minutes renumbering everything by hand.

Numbered headings solve this. When your heading numbers are generated automatically, you can add, remove, and reorder sections freely without ever touching a number again. The numbering updates itself.

This tutorial walks through how to set up automatic numbered headings in Confluence using Modern Numbered Headings for Confluence, an NGPILOT app that installs in seconds and works immediately — no configuration wizards, no macro nesting, no custom CSS.

QR codes bridge the gap between physical and digital information. A printed QR code on a poster, equipment label, or business card lets someone open a web page, join a WiFi network, or save a contact without typing a single character. For teams using Confluence as their knowledge base, adding QR codes to pages turns static documents into interactive touchpoints.

The challenge is that Confluence does not include built-in QR code generation. You either use a third-party QR generator website, download the image, and upload it manually — or you install a marketplace app that generates QR codes directly inside Confluence pages. The second option is faster, keeps your QR codes up to date when page URLs change, and avoids juggling image files.

QRCode for Confluence by NGPILOT is a lightweight app that embeds QR codes directly into Confluence pages using a simple slash command. It supports URLs, plain text, email addresses, phone numbers, and any other string. You can customize the size, and the QR code renders inline on your page.

This guide covers everything you need to know: how to install and use the app, what content types you can encode, creative ways teams use QR codes in Confluence, and best practices for making sure your QR codes actually get scanned.

Flowcharts are one of the most common diagrams teams add to Confluence pages — for process documentation, onboarding, decision trees, and troubleshooting guides. This article shows three ways to create them using NGPILOT apps.

Confluence's native code block macro renders JSON as plain text — no real syntax highlighting, no themes, no copy button. For API documentation, config references, or any page where JSON needs to be readable, that's not good enough. There are two better ways to embed JSON in Confluence, and the best one depends on how you want readers to interact with the data.

Inconsistent Jira tickets waste time during grooming, sprint planning, and reporting. Issue templates solve this by standardizing the fields, descriptions, and checklists that appear on every new ticket. This guide covers how to set up and get the most from Modern Issue Templates for Jira.

Modern Code Blocks adds a Monaco-powered editor and syntax highlighting for 85+ languages in Confluence. This article explains embedding, theming, and performance tips.

Collecting attachments from many Jira issues can be tedious. The Simple Bulk Attachment Downloader app automates parallel downloads and packages attachments by issue for easy sharing and archiving.

Using custom fonts can dramatically improve readability and branding in Confluence. This guide shows how to use the Google Fonts for Confluence app to apply fonts, configure previews, and balance performance.

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

Excalidraw-powered whiteboards let teams sketch ideas directly inside Jira issues. This quick guide covers creating boards, saving snapshots, and sharing with team members.

Exporting Jira issues to Excel or CSV is useful for reporting, audits, and sharing issues with stakeholders. This guide walks through exporting filtered results using the Simple Bulk Issues Excel CSV Export app with practical JQL examples and field-selection tips.