52 posts tagged with "jira"

On October 13, 2026, Atlassian's latest Cloud price increase took effect — Jira, Confluence, Jira Service Management, Bitbucket, Guard, the works. If you're the billing admin, you've seen it land. This post is the breakdown in one place, what it means at your next renewal, and the part we can speak to directly: not one of our 36 apps is raising its price. Not now, not at your renewal.

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.

Mermaid 12.2.0 shipped upstream on October 13, and it is live in all three NGPILOT diagram apps: Enhanced Markdown for Confluence, Mermaid Plus Diagrams & AI Agent for Confluence, and Mermaid Plus Diagrams for Jira. It's a small release with one feature you can see from across the room — mind maps that color themselves by hierarchy depth — and a set of quiet fixes that matter more on Confluence than anywhere else, because Confluence pages are where multiple diagrams share one page.

Jira and Confluence are the two products most people picture when they hear "Atlassian." They are frequently sold together, deeply integrated, and yet regularly confused — even by teams that use both every day. This guide explains what each is actually for, where each one shines and struggles, and how to decide which tool a given piece of work belongs in. The goal is to give you a mental model you can apply to any task, not a feature checklist.

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.

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.

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.

Mermaid 12 is the biggest release the diagram language has had in years — and as of today it is live in all three NGPILOT diagram apps: Enhanced Markdown for Confluence, Mermaid Plus Diagrams & AI Agent for Confluence, and Mermaid Plus Diagrams for Jira. You get the headline feature immediately: UML use case diagrams, the diagram type Confluence and Jira teams have been asking for since requirements documents moved out of dedicated UML tools.

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.

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.

If you have ever exported a project for reporting, an audit, or a migration, you have probably run into Jira Cloud's export limit without being warned first: the export finishes, the file looks complete, and the row count quietly stops at 1,000. This article explains where that limit comes from, then compares the three practical ways to export larger issue sets in 2026.

Jira and Confluence are the two products most people picture when they hear "Atlassian." They are frequently sold together, deeply integrated, and yet regularly confused — even by teams that use both every day. This guide explains what each is actually for, where each one shines and struggles, and how to decide which tool a given piece of work belongs in. The goal is to give you a mental model you can apply to any task, not a feature checklist.

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.

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.

Sprint retrospectives are supposed to be the engine of continuous improvement. But for many teams, they devolve into the same complaints, the same vague commitments, and the same problems month after month. The retro becomes a ritual without results.

The issue is not the concept — it is the execution. Without structure, facilitation, and follow-through, retros produce feelings but not changes. This guide fixes that.

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

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.

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.

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.

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.

Jira issues accumulate attachments fast -- screenshots from QA, log files from production incidents, design mockups from product, contracts from legal. Before long, a single project can hold thousands of files across hundreds of issues. Two questions come up repeatedly: "How do I download all of these at once?" and "How do I make sure the right files -- and only the right files -- are attached?"

NGPILOT builds two apps that address these questions from different angles. Simple Bulk Attachment Downloader for Jira handles bulk exports -- downloading many attachments in one organized ZIP. Attachment Reviewer for Jira handles inbound control -- enforcing file type and size policies on every upload. This post compares both in detail so you can decide which one your team needs (or whether you need both).

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.

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.

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.

Managing a Jira instance at scale means sooner or later you will need to act on dozens, hundreds, or even thousands of issues at once. Whether you are migrating projects, cleaning up stale tickets, bulk-downloading attachments for an audit, or exporting an entire backlog for offline analysis, doing it one issue at a time is not realistic. Bulk operations let teams apply the same change across many issues simultaneously, saving hours of repetitive manual work and reducing the risk of inconsistency that comes with editing tickets individually.

However, bulk operations carry real risk. A single misconfigured bulk edit can change the status, assignee, or custom field value of hundreds of issues in seconds, and Jira does not offer a one-click undo. That is why understanding the right tools, permissions, safeguards, and workflows is critical before you run any bulk job. This FAQ covers the most common questions teams ask when planning and executing bulk operations in Jira, from safety and rollback strategies to performance tuning and permission requirements.

Exporting Jira issues sounds simple until you try it at scale. Jira's native CSV export works for small result sets, but teams quickly hit field mismatches, encoding errors, custom field headaches, timeouts on large projects, and the question of what to do with attachments. This FAQ walks through each common problem and the practical fix — most of which Simple Bulk Issues Excel CSV Export for Jira handles out of the box.