Skip to content

As of

How to find the root causes behind your highest IT ticket volume

Finding the root causes behind high IT ticket volume means grouping tickets by what caused them, not by the category picked at intake, and then checking each group against what changed in your organization.

Every service desk can tell you its volume. The dashboards are good now: tickets by week, by category, by team, by channel. Ask one of them why volume went up this quarter and it will usually answer with a category. "Access requests" is up. "Software, other" is up.

That is a description, not a cause. Nobody can fix "access requests". Someone can fix the HR attribute that stopped updating a group in the identity provider, or the certificate that expires every twelve months with no owner.

The discipline for finding those causes already exists. Problem management, Pareto charts and the 5 Whys are decades old and they work. What they need is tickets grouped by cause, and most service desks don't have that. They have tickets grouped by the field someone chose before anyone knew the cause.

What tools can find the root causes behind high IT ticket volume?

Three kinds of tool do part of the job: the problem management module in your service management platform, ticket text analytics, and AIOps or observability tools. Each sees one layer of the problem. None of them, on its own, joins a ticket to the person who raised it, their access and what changed around them, which is where most repeated causes sit.

That join is the argument of this guide. The method below works with any of these tools, and it will show you where yours stop.

Why your ticket categories point at the wrong cause

Categories are picked by hand at intake. The requester picks one from a dropdown, or the analyst picks one while triaging. Either way, the choice is made at the moment the least is known: the person sees a symptom and files it under the nearest heading.

So the category records the symptom, and the same cause lands under several headings. An expired certificate shows up as "Login", "Email" and "VPN". A broken onboarding step shows up as "Access request" and "Hardware". Meanwhile one busy heading hides five unrelated causes. "Software, other" is often the largest category in the system, because it's where people put tickets they can't place.

There's a second distortion. Categories are rarely corrected at close. The analyst who found the real cause writes it in the resolution notes, in free text, and the category stays as filed. Your reporting reads the field that was wrong and ignores the note that was right.

A method you can run on 90 days of tickets

You can do this with an export and a spreadsheet. It takes a few days of focused work the first time.

  • Pull 90 days of closed tickets with the description, the resolution notes, the requester and their team, the date and the assignee. Ninety days is long enough to show what repeats and short enough that your systems haven't changed shape since.
  • Group by cause, not by category. Read the resolution notes, not the category. Give each ticket a cause label in plain words ("SSO certificate expired", "new starters missing the sales reporting group"). Expect the first few hundred to be slow and the rest to fall quickly into groups you've already named.
  • Draw the Pareto chart. Sort the cause groups by count. A handful usually carries a large share of the volume. Those are your candidates.
  • Run the 5 Whys on the top groups. Ask why the tickets happened, then why that happened, until the answer is something a person or a system can change.
  • Check each answer against what changed. For every cause, find the date it started and what changed in the week before: a role, a group, a policy, a configuration, a vendor update.

The fifth step is the one most write-ups leave out, and it's where the causes worth fixing usually turn up.

Take a group of tickets labelled "can't open the sales dashboard". The first why is that people lack the reporting role. The second is that the role is granted by an identity provider group. The third is that the group is assigned from a job title in HR, and the titles changed in a reorganization two months ago. The fix is one mapping rule, and no ticket says so.

What each kind of tool sees, and what it misses

Problem management modules in service management platforms give root cause work a home: a problem record, linked incidents, a known error and a workaround. That structure is right. But it only works after someone notices a pattern and opens a problem record. The module records the investigation; it doesn't start one. And it inherits the categories, so the pattern has to be visible through them first.

Ticket text analytics clusters tickets by their wording, which gets past bad categories. It is good at finding "VPN keeps disconnecting" written forty different ways. It is weaker when one cause produces different words. A slow app, an unreachable file share and VPN drops can be one change, and they read nothing alike. Text analytics will give you three tidy clusters and no link between them.

AIOps and observability tools see infrastructure signals: latency, error rates, deploys, configuration changes on the systems they monitor. When a cause is technical and monitored, they often find it first. They don't see people. A role change that left a team without access to one app produces no error and no alert. It produces tickets.

Each tool is honest about its layer. The trouble is that a repeated cause rarely stays in one.

What an AI agent needs to see a root cause

Most high-volume causes are a change meeting a group of people. A firewall rule is tightened on a Tuesday, and by Wednesday the queue holds tickets about a slow finance app, an unreachable file share and VPN drops, all from one office. A team moves under a new department in HR, and the access that came from the old department quietly stops.

To see either of those as one cause, a tool needs four things together: the ticket, the person who raised it, what that person can reach and through which devices and groups, and what changed recently in any of those. Text sees the first. Observability sees part of the last. The problem module sees whatever a person types into it.

This is also what an AI agent needs to group tickets well. Grouping on wording alone is the text analytics result again. Grouping on who is affected, what they share and what changed is closer to how an experienced analyst works when they say "these are all the Frankfurt office" or "these all started after Tuesday". The analyst does it from memory. An agent can do it from a model that is kept current.

How an AI agent groups tickets by cause in STLabs

STLabs groups related tickets by cause and removes duplicates as they arrive, in Automated Triage. The grouping is built on Axiom™, the live model of your people, devices, apps and access that STLabs keeps current from your HR, identity and device systems, with no configuration database to maintain by hand. When a ticket needs a person, it arrives with the requester's identity, device, access and recent changes already attached, and every resolution shows the reasoning behind it.

That changes when root cause work happens. Instead of a quarterly export and a spreadsheet, the cause groups exist as the tickets come in. In Analytics you can ask "What's driving ticket volume this month?" in plain words and get the clusters behind the number, broken down by root cause, then pin the answer as a standing panel. This is what AI-native service management looks like for problem management: the grouping is a by-product of handling each ticket, not a separate project.

Your team still owns the fix. When the same resolution keeps repeating inside a group, Workflows spots it and proposes a workflow. It is checked before it runs, with a dry run on past tickets, and approved under the rules your team sets in Policies & Approvals. Every workflow is versioned, so it can be reviewed and rolled back.

When a cause hits everyone at once, the same grouping handles the flood; that case is in How to handle a ticket storm. For how problem management carries over from ITIL, see ITIL without the paperwork.

How to test this on your own systems

Run the method above by hand on last quarter's tickets first. It gives you an answer key.

Then pick the top three cause groups you found and ask your current tooling to find them without you. Does any report show them as groups, or only as categories? Does it link the tickets in each group to the change that started them, with a date? For the cause that came from a role or group change, can it tell you who else has the same gap and hasn't filed a ticket yet?

That last question separates tools that read tickets from tools that know the organization. If the answer takes a person and an afternoon, the join is still being done by hand.

Fix the cause, then the count

None of this replaces the service desk you already run. STLabs works alongside it with two-way sync, so you can start with the triage and analytics view while the queue stays where it is. Teams go from integration to results in five days; the plan is in Moving to STLabs from your current service desk.

Your ticket volume was never the thing to fix. It was the list of causes nobody had sorted yet.

Frequently asked questions

What usually causes high IT ticket volume?

A small number of repeated causes, often a recent change meeting a group of people: an expired certificate, a role mapping that missed an app, a configuration change. Ticket categories tend to hide them because they record symptoms.

What tools can do root cause analysis on ITSM tickets?

Problem management modules, ticket text analytics and AIOps or observability tools each cover part of it. The causes they miss sit in the link between a ticket, the person's access and what recently changed.

How do you find the root cause of repeated IT tickets?

Pull 90 days of tickets, group them by cause from the resolution notes, sort the groups by count, then ask why on the largest until you reach something a person or system can change.

Why are ITSM ticket categories unreliable for root cause analysis?

They are picked by hand at intake, before anyone knows the cause, and rarely corrected at close. One cause lands under several categories, and one busy category hides several causes.

See it on your tools.