Three steps: you see what your Jira already knows about your last quarter, you check it against tickets you remember, and then you hand the same view to the team.
On a setup call we connect a read-only Jira user and pick the teams to review. Recadence maps your statuses, ticket types and team roles from the change history already in your tickets, and you verify the mapping. That is the whole configuration. The first thing you see is your own last quarter, not a demonstration. There is no dashboard to build first.
It loads invisibly at first, available only to management. Teams are introduced when you decide they should be, by adding the Jira plugin.
Everything is read from Jira change history: how work moved between statuses and how long it waited at each one. Every one of those moves was a decision the team made that day about what to prioritise. It is behavioural data, not individual activity data. Recadence doesn't look at how many commits or pull requests anyone produced along the way.
If you only measure one thing, measure the cost of being delayed. Release Cycle Time is the working days from when a ticket first starts in progress until it is released. It counts working days because each workday is a priority decision, and weekends are usually not.
Once a ticket meaningfully starts, the clock doesn't stop, especially when it's blocked.
Cycle Time goes up when delivery is disrupted. It comes down when things improve. And it is resistant to gaming: the only way to sustainably reduce it is to release more often, making priorities more transparent.
This metric reflects team outcomes, not individual performance. Individual names aren't used in reports; team roles are used instead (e.g. "QA" or "Front-end Developer").
The days spent waiting on another team are included in the count. So are the days after the ticket was reverted to To Do, and the days it sat between review and test. From a team outcome perspective, once work has meaningfully started, all of that time is delivery capacity being consumed. If the number left the external block out, it would say the ticket took less time than it did, and the team would have no evidence of what that dependency cost them.
Planned work shouldn't take more than half a sprint.
Small, frequent releases are the foundation.
Speed without quality creates more work, not less.
When something breaks, how fast does the team recover?
These four DORA-influenced metrics balance each other. Optimising one at the expense of another always shows up. The only way through is to genuinely improve.
Underneath the four, Recadence tracks over a hundred behavioural facets of how each team's work moves. Engineering leaders are shown a small set of them as structural health indicators: WIP creep, external blockers growing, reactive work consuming capacity, defect backlog build-up, unfinished carry-over, cancelled work. They tell you when something needs attention, so you know when to step in and offer a team support without chasing updates or depending on self-reporting.
Some teams measure themselves against industry benchmarks, but every team, every project and every company is a different situation. The most useful benchmark is how the team itself has performed so far, because that is the one it can continuously improve against. Recadence builds that baseline from the history already in your Jira, in one pass, for every team you point it at. It is the basis on which the impact of AI adoption, a change in team structure or hypergrowth can be measured, particularly against risk thresholds.
If a diagnostic is all you need, this first step is enough on its own. The next two are for when a team wants to improve on the evidence in front of them.
As a catch-all metric, cycle time needs to be explainable. Every figure in Recadence is derived from the status history of the tickets behind it, deterministically, and every figure opens into those tickets. Teams can drill from a summary finding down to individual tickets. If you don't believe a number, open it and find a ticket you remember. Its timeline shows where its days went, status by status.
Whether or not a team uses sprints for planning, all teams need to reflect regularly in order to improve. Each interval, Recadence dives into the tickets themselves: where time actually went, what was planned versus reactive, where work stalled, and what each delay cost. Slow pull requests, reversions from QA, mid-sprint scope changes, blocking dependencies outside the team.
The breakdown separates what the team controls from what they don't, so the conversation starts with evidence instead of defensiveness.
Delivery problems usually repeat. Delays from large tickets in one sprint cause downstream bottlenecks in the next. The symptoms look different each time, but they share root causes. Recadence correlates hundreds of behavioural signals across your last four sprints to find the compound patterns, and every candidate cause is ranked by how much of the lost time it accounts for and how sure the evidence is.
Most teams don't value an AI analysis whose observations change every time it's asked. In Recadence, the findings don't come from an AI LLM. Every count, share and ranking above is computed deterministically from ticket history, and produces consistent, statistically defensible findings. When AI is enabled, that analysis is already finished before the AI sees it. What the AI does is summarise the results into discussion prompts at three depths: a top-level summary like the one above, a two-minute brief for each focus area with recommendations specific to the team's data, and underneath that a 10–15 minute guide with the predictive analytics and the relevant theory, in context with the team's actual problem rather than a list of books to read.
The AI summarises and explains; it doesn't invent. Nothing appears in a summary that isn't in the numbers beneath it. Your ticket descriptions and comments are never sent to an AI provider. The only data transmitted is anonymised operational metadata, and if you'd prefer, AI summarisation can be switched off altogether.
Tell a team to make their tickets smaller and you'll hear: "Yes, but releasing wastes too much time." "Yes, but QA is the real bottleneck." "Yes, but the other team blocks us." They're usually right. And that's exactly the point. Each "yes, but" is a bottleneck, and the analysis above measures it, with the evidence to answer it every sprint. That's why our company is called Yes But How.
Not every team starts in the same place, and the analysis finds different things depending on where a team is. Where planning is broken, it points at work that was never ready and estimates that were never tested, because the basics have to come before cycle time optimisation makes sense. Where tickets are large but the team has the discipline and capability to change, it shows them where the time went inside the tickets that outgrew the sprint, and they fix it. Where a team is already working in small tickets, it finds the queues between them: code review, test, release batches. A blanket approach will fail. Recadence shows you which teams need what, across your entire portfolio, without depending on self-reporting.
What your teams can measure, you can delegate. The same analysis is available to the team inside Jira, on the ticket and from the board and backlog menus, and it respects the Jira permissions they already have. No external tool, no second login.
Recadence is designed to be used in retrospectives, not stared at on a wall. Teams are sometimes given an adjustment period first, a window where the focus is on understanding the data rather than acting on the numbers. After that, retrospectives run on three principles.
The target is an average Release Cycle Time of less than half a sprint, for most teams roughly a week, reached by optimising the team's own bottlenecks in retrospectives. The threshold exists because if work routinely takes longer than half a sprint, the team can't reflect, adapt and improve within a retrospective cycle. A team can't sustain short cycle times without fixing the structural problems underneath: slow deployments, manual QA bottlenecks, poor planning, hidden dependencies, unclear requirements. Every one of these shows up as friction. And if a team improves cycle time at the expense of quality, the defect rate will show it.
There's a reason teams resist sprint demos. Without short cycle times and visible blockers, demos become a stage where someone explains why nothing was released, or watches senior leadership argue about strategic issues the team can't control.
When cycle time is short, demos are fundamentally different. The team has finished, released work to show, and the rule is to only present work that is live in production, never work that is "almost finished". External blockers are already measured and visible. The focus stays on the next minimum viable change, not on relitigating the last quarter. Trust built on cadence, not promises.
Cycle time as a team target means bottlenecks are where the biggest impact is. Teams separate what they control from what they don't. Instead of waiting for large technical investments to be prioritised, they slice a minimal fix, celebrate the result, and slice again. Improvements pay for themselves.
Agile doesn't make delivery predictable. It makes it transparent. When cycle times are short, scope changes become cheap course-corrections instead of expensive surprises. "When will it be done?" becomes "what should we focus on next?"
External blockers, cross-team dependencies, and reactive distractions become measured and visible. Teams can show exactly what's within their control and what isn't. The conversation shifts from blame to support.
When QA wait times halve because the team invested in automation, the before and after are right there. Improvement stops being theoretical.
Released work to show every interval, and leadership reporting that gets easier as the increments get smaller.
We'll connect your Jira on a quick setup call and walk you through your first analysis. Five minutes, your data, no slides.
Start free trial