← All posts

Best Practice: Managing the Service Desk

For most clients, the service desk isn't a support function sitting behind the product — it is the product. A client rarely experiences your monitoring stack, your backup jobs, or your documentation directly; they experience what happens when something breaks and they ask for help. Every other discipline an MSP practises is invisible until the service desk either confirms it's working or exposes that it isn't.

This guide is platform-agnostic — the practices here apply whether you're running a PSA, a standalone ticketing tool, or something you've cobbled together, and they're drawn from how mature IT service management (ITSM) and ITIL-aligned operations actually run a desk well. The goal throughout is the same: make the desk predictable for the client and sustainable for the team, rather than a queue that gets by on individual heroics.

1. Design intake so triage doesn't start blind

A triage decision is only as good as the information it's made from. If a ticket arrives with no contact, no category, and no sense of what's actually broken, the first thing that happens isn't triage — it's someone chasing the reporter for the details that should have been captured at intake.

Fix the channels, not just the form. Most desks take tickets from more than one place — email, a portal, a phone call, a monitoring alert. Each channel needs to land in the same place with the same minimum information, or triage quality becomes a function of which door the request came through rather than what it actually is.

Make a small number of fields mandatory, and mean it. A contact (so there's someone to follow up with and eventually bill), a category, and some indication of impact are usually enough — don't make intake so heavy that people route around it, but don't make it so light that triage is guesswork.

Use a small, stable set of categories, not a sprawling one. A category list that's grown organically over years, with overlapping or near-duplicate entries, stops being useful for routing or reporting — it just becomes another thing triage has to interpret rather than trust. Review and prune it periodically rather than only ever adding to it.

Distinguish incidents from requests at the point of intake, not later. Something broken (an incident) and something wanted (a service request) have different urgency profiles and often different approval paths — conflating them into one generic "ticket" type makes both harder to prioritise correctly.

2. Prioritise by impact and urgency, not who shouts loudest

The single most common source of a dysfunctional queue is priority set by volume of complaint rather than by a consistent rule. A persistent caller doesn't make their issue more urgent; it just trains the desk to reward persistence over genuine impact, and the team ends up firefighting whoever's loudest instead of what actually matters most.

Impact asks how much of the business is affected — one person, one team, or everyone. Urgency asks how quickly the consequences get worse if nothing happens. Combine the two rather than using either alone — a high-impact issue that can comfortably wait a day is not the same priority as a high-impact issue that's actively getting worse by the hour. The usual way to do this is a small grid: impact down one side, urgency across the other, and a priority in each cell.

Write the matrix down and make it the actual rule, not a vague instinct everyone applies slightly differently. A category or issue type should map to a sensible default impact and urgency so triage doesn't have to make a fresh judgement call every single time — reserve genuine judgement for the cases that don't fit the pattern.

Resist priority inflation. If everything ends up P1 or P2, the scale has stopped doing its job, and a genuine P1 no longer stands out from the noise. Priority creep is usually a sign the matrix isn't trusted — worth revisiting the categories feeding it rather than just reminding people to use lower priorities.

3. Set SLA targets that mean something

An SLA is only useful if it describes a real commitment and is measured honestly against it. A target nobody checks, or one so loose it's never actually at risk, isn't an SLA — it's decoration.

Separate response from resolution. "We'll acknowledge this within 15 minutes" and "we'll have this fixed within 4 hours" are different promises, and conflating them into one number either makes the response target meaningless or the resolution target unrealistic. Track both, by priority.

Match coverage hours to the priority, not a blanket policy. A P1 commonly needs 24/7 coverage since a company-wide outage doesn't wait for business hours; lower priorities can reasonably sit within standard business hours. A single coverage window applied uniformly across all priorities either over-commits on the low-priority end or under-commits on the critical end.

Pause the clock honestly when the ball is in the client's court. If a ticket is waiting on information only the client can provide, the SLA clock should pause rather than quietly accumulate a breach that was never the desk's fault — but only pause it for a genuine wait, not as a way to disguise a slow response.

Monitor compliance continuously, not only when a client complains. A dashboard the team actually looks at regularly catches a slipping SLA while it's still a trend, not after it's already become the client's main talking point in a renewal conversation.

4. Keep ownership and status honest

A ticket with no clear owner belongs to everyone, which in practice means it belongs to no one. The moment two people assume the other is handling something, it stalls — invisibly, because nothing about the ticket looks obviously wrong.

One named owner per ticket at any given time, even if the work genuinely passes between people over its life. A ticket can be reassigned, but it should never be ambiguous who's responsible for it right now.

Keep status values honest and few. Status should describe what's actually true — waiting on the client, waiting on a vendor, actively being worked — not what someone hopes is true or what's administratively convenient. A long list of fine-grained statuses tends to get used inconsistently; a short, meaningful list gets used correctly.

A status that implies someone else needs to act should trigger something, not just sit there. "Waiting on client" with no follow-up after a sensible interval is indistinguishable from a ticket nobody's watching — set a cadence for revisiting anything sitting in a waiting state, rather than trusting it'll surface itself.

Audit the backlog for tickets that have gone quiet, not just ones that have breached. A breach is already visible on a dashboard; a ticket that's merely gone stale — no status change, no update, nothing overtly wrong — is the one that erodes trust quietly before anyone notices.

5. Build the knowledge base as a by-product, not a project

A knowledge base built as a dedicated initiative — block out two weeks, document everything — tends to go stale fast, because it was written in one burst disconnected from the work that actually surfaces what's worth documenting. The desks with genuinely useful knowledge bases build them continuously, as a near-automatic step in resolving a ticket, not as separate homework.

Capture the fix while it's fresh, not from memory later. The moment a non-trivial issue is resolved is the moment the detail is clearest in the resolver's head — a quick article then costs minutes; reconstructed a month later from a vague memory, it costs much more and is often wrong in some small but costly way.

Link the article back to the ticket it came from, and forward from future tickets to it. A knowledge base that isn't surfaced at the point someone's triaging a similar issue might as well not exist — the value isn't in having written it, it's in someone finding it in the ten seconds they have to look.

Write for the person who didn't live through the original issue. An article that only makes sense to whoever wrote it isn't really documentation — it's a note to self. A colleague unfamiliar with the specific incident should be able to follow it and actually resolve the next occurrence.

Prune as deliberately as you add. An article describing a system you no longer run, or a workaround for a bug that's since been fixed properly, is worse than no article at all — it actively misleads whoever trusts it next.

6. Communicate proactively, especially when nothing has changed yet

Silence is read as neglect, even when real work is happening behind it. A client who's heard nothing since they raised a ticket has no way to distinguish "this is being actively investigated" from "this has been forgotten" — and in the absence of information, people assume the worse one.

Set an update cadence by priority, and hold to it even when there's no news. "Still investigating, no update yet, next check-in at 3pm" is a genuinely useful message — it costs the client nothing to receive and tells them the issue hasn't been dropped, which is most of what they actually want to know during an outage.

Say what's happening in terms the client can act on, not internal process detail. "We've identified the cause and are testing a fix" serves the client; "ticket reassigned to tier 2" mostly serves your own workflow. Translate the update to what matters on their side.

Close the loop explicitly, don't let a ticket just go quiet after the fix lands. Confirm the resolution with the person who reported it before marking it resolved — a ticket closed without that confirmation risks a silent reopen later, or worse, a client who assumes nothing was actually done because nobody told them it had been.

7. Measure a small set of metrics, and actually review them

More metrics isn't more insight — a dashboard with thirty numbers on it gets glanced at and ignored. A handful, reviewed on a fixed cadence, drives more change than a comprehensive one nobody has time to interpret.

Metric What it tells you Watch for
First response time Whether triage is keeping pace with intake Creeping up as volume grows, even if resolution time looks fine
Resolution time (by priority) Whether work is actually getting done, not just acknowledged A gap between response and resolution that keeps widening
SLA compliance Whether commitments are being kept, not just set A rate that looks fine in aggregate but hides one priority tier failing
First-contact resolution How much is being solved without a second touch A falling rate often means knowledge base or triage quality slipping
Reopen rate Whether "resolved" tickets are actually staying resolved A rising rate points at closing tickets before genuine confirmation
Backlog trend Whether the queue is growing or shrinking over time A slow, steady climb is easy to miss day to day and obvious in hindsight
CSAT Whether the experience matched the numbers A good SLA record with poor CSAT usually means communication, not speed, is the problem

Review on a fixed cadence, not only when something's visibly wrong. A short weekly look at trend lines catches a slow slide before it becomes a client-facing problem; reviewing only in response to a complaint means you're always a step behind.

Use metrics to find where to look, not as a verdict on their own. A number moving the wrong way is a prompt to ask why, not an automatic conclusion — the same first-contact-resolution drop could mean a knowledge base gap, a hard new category of issue, or a staffing problem, and those need different fixes.

Pre-flight checklist for a disciplined service desk