Reporting in Jira: A Guide to reporting in jira and Dashboards

Let's be honest, for many teams, Jira feels like a digital black hole. Tickets go in, they get updated, and eventually, they get closed. But what actually happened in between? Without good reporting, you're just guessing.

This is where you move from simply using Jira as a glorified to-do list to wielding it as a powerful analytical tool. It's the difference between tracking tasks and truly understanding your team's workflow, bottlenecks, and overall project health.

From Simple Task Tracker to Your Project's Command Center

I've seen it countless times: a team is busy, but they aren't sure if they're being productive. The real lightbulb moment happens when they start using Jira’s reporting features to get clear, data-backed answers to the questions that really matter.

Instead of relying on gut feelings during stand-ups, you can pull up a dashboard and know for sure:

Are we introducing new bugs faster than we’re squashing them?
Where are tickets getting stuck? What's the biggest bottleneck in our development cycle?
How much unplanned work is actually derailing our sprints and throwing off estimates?

This isn't about creating complicated charts to impress management. It's about giving your team the insights they need to improve their own processes.

Making Sense of the Data

Every time someone creates an issue, logs time, or moves a ticket from "In Progress" to "In Review," they're creating a data point. On its own, a single ticket's journey isn't that telling. But when you aggregate thousands of these data points, patterns emerge. Reporting in Jira is the art of turning that raw data into intelligence you can act on.

The scale here is massive. In a recent quarter, Atlassian's revenue grew 23% to $1,586.3 million, largely thanks to cloud products like Jira. More than 65,000 organizations use Jira for service reporting alone. You're working with a tool built to handle data at an immense scale, connecting dev, IT, and business teams.

To give you a clearer picture, here’s a quick breakdown of how you can approach reporting in Jira, from the most basic to the most advanced.

Jira Reporting Levels At a Glance

Reporting Method	Best For	Complexity
Filters & JQL	Quick, specific queries and saving searches.	Low
Built-in Reports	Standard Agile metrics (burn-down, velocity).	Low-Medium
Dashboard Gadgets	At-a-glance project health and key metrics.	Medium
Exports (CSV/XML)	Deep analysis in external tools like Excel or Google Sheets.	Medium-High

Ultimately, it's about building a system that feeds you the right information at the right time, without forcing you to dig for it.

By transforming your Jira project from a simple task tracker into an analytical tool, you empower your team to own their process and proactively solve problems before they escalate.

Why This Is Crucial for Small Teams

This is especially true for solo founders and small engineering teams who don't have the luxury of a dedicated QA person or project manager. You can't afford to spend hours in spreadsheets or conduct lengthy post-mortems for every little thing that goes wrong.

Smart, automated reporting in Jira gives you that immediate feedback loop. It helps you stay lean and effective. A great first step is to ensure your data is clean and consistent—using a solid template for your issue log can make all the difference. When your input is structured, your reporting output becomes infinitely more reliable. It’s all about making informed decisions, fast.

If you want to get real answers from your Jira data, you have to learn to speak its language. That language is Jira Query Language (JQL). Forget thinking of it as some complex code; it's more like a set of search commands that let you have a direct conversation with your project data.

Everything from custom reports to the gadgets on your dashboard starts with a good JQL query. It’s the difference between a generic search for "login bug" and getting a precise list of issues that actually need your attention right now.

Go Beyond Basic Search with JQL

Let's get practical. A classic problem is trying to find tickets that have gone stale and are holding up a sprint. A basic search is useless here, but with JQL, you can find them in seconds.

For instance, imagine you need to find all high-priority bugs in the current sprint that haven't been updated in over three days. This query does exactly that:

project = "YourProject" AND sprint in openSprints() AND priority = High AND status != Done AND updated <= -3d

Suddenly, you don't just have a list. You have an action plan. This tells your team precisely where to focus to get the sprint back on track. This ability to layer filters for project, status, priority, and time is what makes JQL so indispensable.

Even a simple query can cut through the noise. The screenshot below shows a basic JQL search for all issues updated in the last day.

Just like that, you’ve filtered out all the old, irrelevant tickets and can focus on what’s happening now. Getting comfortable with these commands is the first step toward building reports that tell a clear story.

Practical JQL Recipes for Your Team

The fastest way to get good at JQL is to start using it. Here are a few of my go-to queries that you can copy, paste, and adapt for your own projects today.

Spot potential scope creep: sprint in openSprints() AND issue in addedAfterSprintStart() This one is a lifesaver. It instantly flags any issues that were shoehorned into the sprint after it already started—a classic sign of unplanned work.
Check a feature's progress: parent = "EPIC-123" AND status != "Done" Just swap in your feature's epic key (like "EPIC-123") to get a live look at all the remaining work for that specific initiative.
Monitor your personal workload: assignee = currentUser() AND status in ("To Do", "In Progress") I encourage every developer to save this query. It creates a perfect, personalized "My Work" list that shows exactly what's on your plate right now.

With JQL, you stop just looking at data and start asking it questions. You get to play detective, digging into your project workflow to find the real story buried in the tickets.

As you start mastering these queries, you can track more sophisticated developer metrics. If you need some ideas on what's worth measuring, our guide on key metrics for QA is a great place to start, and you can track most of them with JQL. These saved queries are the foundation for the powerful dashboards and reports we’ll build next.

Using Jira's Built-In Reports for Quick Wins

While it's tempting to dive straight into complex JQL queries, you don't always have to build reports from scratch. Jira has a handful of excellent built-in reports that are perfect for getting quick, actionable insights into your team's work. Think of them as your project's dashboard warning lights.

These reports are ready to go right out of the box and give you a visual handle on the common questions every agile team asks. They pull directly from your project data to help you see trends, bottlenecks, and wins with zero setup. Especially for smaller teams that may not have a dedicated project manager, these reports are an absolute lifesaver for keeping everyone aligned.

Monitoring Sprint Health with the Sprint Report

The Sprint Report is your daily pulse check during an active sprint. At its core, it's a classic burn-down chart, showing you the work remaining against the time left. But where it really shines is in its ability to expose scope creep.

Anytime work gets added to the sprint after it has started, you'll see an upward spike on the chart. This makes those "quick little additions" impossible to miss. I've brought this report up in countless daily stand-ups to ask, "I see a new ticket was added yesterday. What did we agree to de-scope to make room for it?" It’s a simple question that keeps the conversation honest and the sprint goals protected.

The Sprint Report isn't just a chart; it's a conversation starter. It makes scope creep visible to the entire team, fostering accountability and protecting the sprint goal from constant interruptions.

This simple visual is fundamental to running an effective sprint and is one of the most powerful tools for reporting in Jira.

Forecasting with the Velocity Chart

When you need to look beyond the current sprint and plan for the future, the Velocity Chart is your best friend. This report shows you exactly how much work the team has delivered over previous sprints, typically measured in story points. It breaks down two critical figures:

Commitment: What the team planned to do (the total story points committed to at the start of the sprint).
Completed: What the team actually got done by the end of the sprint.

By looking at the "Completed" bar over the last several sprints, you can calculate a pretty reliable average velocity. For example, if your team consistently finishes around 25 story points sprint after sprint, you can walk into your next planning session with confidence, knowing that's a realistic target. It beats educated guessing every time.

Checking Your Bug Backlog’s Pulse

Finally, let's talk about technical debt. The Created vs. Resolved Issues Report is a must-watch for any team serious about maintaining product quality. It’s a straightforward line graph that pits the number of new issues being created against the number being resolved in the same period.

If you see that "created" line trending consistently above the "resolved" line, you've got a problem. Your bug backlog is growing, not shrinking. This is a clear signal that the team needs to shift focus and dedicate real time to bug squashing, not just churning out new features. It’s a simple but powerful way to make sure you aren’t creating new problems faster than you’re fixing old ones.

Building Your First Custom Jira Dashboard

While static reports give you a great snapshot, a live dashboard is where the real action is. This is how you turn those powerful JQL queries into a living, breathing command center for your project. A well-designed dashboard gets vital metrics out of buried reports and puts them right where the whole team can see them, every single day.

Think of building a dashboard as telling a story with your data. You're not just throwing numbers on a screen; you're visualizing the team's workflow, shining a light on bottlenecks, and even celebrating progress as it happens. The trick is to combine the right gadgets with the JQL filters you’ve already perfected.

From Filters to Live Visuals

So, you've got your JQL filters saved. Now what? The best next step is to get them out of your 'Saved Filters' list and onto a live dashboard where they can do some real good.

The Filter Results gadget is your best friend for this. It’s basically a window on your dashboard that shows the live results of any JQL query you give it.

Remember that query for finding old, high-priority bugs? project = "YourProject" AND priority = High AND updated <= -3d. By plugging this straight into a Filter Results gadget, you’ve just created a permanent "Stale Bugs" widget. No more manually running searches; the team can now see exactly which tickets need a nudge, just by glancing at the dashboard.

Here’s a look at how different gadgets can come together to provide a full project overview.

This example is a solid starting point. It mixes a high-level summary with individual assignments and a live activity feed. The goal is to arrange these pieces to create a clear narrative, guiding the eye from the big picture down to the specific tasks that need attention now.

Adding Key Reporting Gadgets

To make your dashboard genuinely useful, you'll want to mix and match a few different gadgets. Each one offers a unique way to slice your data, making your reporting in Jira far more insightful. From my experience, these three are essential for any developer-facing dashboard:

Pie Chart: Perfect for seeing how issues are distributed. I often use it to visualize the breakdown of tickets by status, assignee, or priority. A "Bugs by Priority" pie chart, for instance, instantly tells you if the team is getting bogged down with low-impact fixes.
Filter Results: As I mentioned, this is the workhorse. You’ll use it for all sorts of critical lists, like "Bugs Currently in Production," "Unassigned Tickets," or a personal "My Open Tasks" view.
Two-Dimensional Filter Statistics: This one is a real gem for spotting workload imbalances. It's a table-based gadget that lets you cross-reference two data points. For example, you can set it up to show issue priorities in the rows and assignees in the columns. You'll see in seconds if one poor developer is buried under all the high-priority tickets.

Your dashboard should answer questions before your team even has to ask them. When you thoughtfully arrange these gadgets, you create a visual story that focuses everyone on what truly matters, saving them from having to dig for information.

The clarity this brings is huge, especially as team productivity tools continue to advance. Atlassian recently shared data showing that AI integrations are helping users create 5% more tasks and expand their Jira usage 5% faster. You can dig into the numbers yourself in Atlassian's Q2 FY2026 earnings analysis on investing.com. A well-organized dashboard is the perfect canvas to visualize and manage all this increased activity.

Creating Reports Your Development Team Will Actually Use

Here’s a hard truth I’ve learned over the years: a report nobody reads is just digital noise. The biggest hurdle in Jira reporting isn't mastering JQL or wrestling with gadgets; it's getting your team to actually look at and use the data.

If you want your developers to care about your dashboards, you have to build them for them. It’s a subtle but critical shift. Stop thinking about top-down, management-style metrics and start answering the questions your engineers are already asking themselves. Forget "story points completed per quarter." Instead, focus on visuals that make their daily work easier and more transparent.

Focus on Metrics That Matter to Devs

To get real buy-in, your reports need to offer immediate, practical value. A dashboard cluttered with charts that only a VP of Engineering cares about will be ignored, plain and simple. I always recommend starting with just a few high-impact gadgets that address common team frustrations.

What do developers actually find useful? Think about metrics that highlight bottlenecks and spark productive conversations.

Cycle Time: How long does a ticket really take to get from "In Progress" to "Done"? This is gold for spotting where work gets stuck. Is it waiting for review? Blocked by a dependency? This metric tells that story.
Bug Regression Rate: Are old, "fixed" bugs cropping back up? Tracking this helps the team pinpoint weaknesses in their testing process and improve overall code quality.
Pull Request Lead Time: How long do PRs sit gathering dust before getting reviewed? This is a classic collaboration killer. Visualizing it encourages the team to be more proactive with code reviews.

These are the kinds of metrics that help a team solve its own problems. Of course, the data is only as good as what you put in. Making sure everyone logs issues consistently is foundational. If you need a refresher, our guide on how to create an issue in Jira can help standardize your team’s process for much cleaner data.

So, where do you start with building one of these dashboards? It's really a simple three-part process. You start with a specific question, build a query to find the answer, and then pick a gadget to visualize it.

As you can see, every effective gadget is powered by a targeted JQL query. Master the query, and you can report on almost anything.

When deciding what to show, it's crucial to understand who you're building the dashboard for. A developer's "need to know" is very different from a manager's.

Developer-Friendly vs. Management-Focused Metrics

Metric Type	Developer Focus (Actionable)	Management Focus (High-Level)
Velocity	How consistent is our sprint-to-sprint workload? Are we overcommitting?	How many story points were completed this quarter? Is the team on track?
Bugs	What is our bug regression rate? What’s the average time to fix a critical bug?	What is the total number of open bugs? What’s the ratio of bugs to features?
Throughput	What’s our cycle time for features? Where are the bottlenecks in our workflow?	What is the team’s overall output? Are we meeting project deadlines?
Code Quality	How long do PRs wait for review? How many comments do they typically get?	Is our technical debt increasing or decreasing over time?

The key difference is focus: developers need granular, real-time data to improve their immediate work, while management needs aggregated data to see long-term trends.

Make Reporting Effortless and Visible

Even the most thoughtfully designed dashboard is useless if it's buried three clicks deep in Jira. To make reporting a natural part of the team's rhythm, you have to bring the data to them.

The goal is to make data a constant, helpful companion, not a periodic chore. Reports should surface information ambiently, so the team can absorb insights without having to actively hunt for them.

A simple and effective way to do this is with email subscriptions. You can configure any Jira dashboard to send a snapshot directly to a team's Slack channel or email inbox every morning. It’s a great way to kick off the daily stand-up.

For even more powerful, "always-on" visibility, use Jira’s wallboard mode. Throw a key dashboard up on a large monitor in the office or a shared digital space. When critical metrics are always in the team’s line of sight, reporting transforms from a passive task into an active, collaborative tool.

Extending Jira with Advanced Reporting Tools

Jira's built-in reports are a fantastic starting point, but they don't have to be the end of the story. The real leap in efficiency comes when you integrate specialized tools that close the loop between testing, reporting, and actually fixing bugs. This is where modern QA automation comes into play.

Imagine running hundreds of exploratory tests across your web app with just a single prompt. Instead of a developer sinking hours into trying to reproduce a vague bug report, an AI agent can do the grunt work, autonomously finding issues a human tester might never stumble upon.

Bridging Testing and Ticketing

What really changes the game is when these AI-driven tests feed directly into your Jira project. When an AI agent uncovers a bug, it doesn't just log a failure. It automatically generates a perfectly detailed bug report right inside Jira, packed with all the context a developer could ask for.

This isn't just a simple ticket. It’s a complete diagnostic package that eliminates all the usual guesswork. We're talking about things like:

Full session replays showing the exact user path the AI took.
Console logs to pinpoint JavaScript errors.
Network requests that failed or came back with bad data.
Clear, reproducible steps to replicate the issue instantly.

This kind of integration turns a frustrating, vague bug report into a ticket that’s immediately actionable. Developers can see exactly what went wrong without the endless back-and-forth. It’s a direct solution to a huge time sink—research shows that developers can lose over 10 hours a week just trying to track down information.

By connecting an AI testing agent to Jira, you create a seamless pipeline from bug discovery to resolution. The agent finds the bug, and Jira delivers the full story to the right person, instantly.

To get even more out of your data, you can look into sophisticated solutions like AI-powered analytics to spot deeper trends. Integrating a tool like Monito allows even solo founders and small teams to set up this advanced workflow, turning bugs found by AI into developer-ready Jira tickets.

Common Jira Reporting Questions Answered

Even with the best tools, you're bound to hit a few snags when building reports in Jira. It happens to everyone. Let's walk through a couple of the most common questions I hear from teams so you can get unstuck quickly.

How Can I Share Reports With Non-Jira Users?

This is a big one. You’ve built the perfect dashboard, but your key stakeholders—clients, executives, or other department heads—don't have a Jira license. You can't just send them a live link.

Your best bet is to set up a dashboard subscription. This feature lets you email a PDF snapshot of the entire dashboard on a schedule you define, whether it's daily, weekly, or monthly. It’s a clean, simple way to keep everyone in the loop.

If you need to share raw data instead of a visual snapshot, most gadgets (like the Filter Results gadget) have an export option. You can quickly export the data to a format like CSV and then pull it into a tool like Google Sheets or Excel to build your own shareable charts.

A Quick Tip from Experience: When sharing with non-technical folks, always go for the scheduled PDF export. It delivers the high-level summary they need without forcing them to wade through the complexities of a live Jira instance.

My JQL Query Isn't Working Right

We've all been there: staring at a JQL query that seems right but just won't cooperate. When troubleshooting, the first thing to do is hunt for simple syntax mistakes. A misplaced quote or a wrong operator can break everything. Jira's own query builder is a huge help here, as it will usually flag obvious errors in red.

If the syntax looks fine, the problem is probably in your logic. Don't try to debug the whole thing at once. Instead, break your query down into smaller pieces. Test each clause by itself to see if it pulls the issues you expect. For example, start with project = "PROJ", check the results, then add AND status = "Done", and keep building from there. This will help you pinpoint exactly which part of the query is causing the issue.

Ready to stop wasting time on manual bug reporting? Monito is an autonomous AI agent that tests your web app and automatically creates detailed bug reports in Jira, complete with session replays and console logs. Get started for free at monito.dev.