L1 is a tax. Here's how to stop paying it.

Tier 1 IT volume is usually filed under "staffing." It shouldn't be. A staffing problem has a staffing solution — you hire until the queue clears. L1 doesn't clear, because it isn't a capacity gap. It's a tax: a recurring charge on IT that scales with the org, compounds every year, and that hiring only makes more expensive to collect.

This post does the math on that tax, then shows the one thing that actually stops you paying it. The short version: you don't reduce a structural tax by working harder against it. You remove the thing being taxed. That's the difference between deflecting L1 and eliminating it — and it's the logical next move after you've seen what Tier 1 really costs in The IT helpdesk math.

Why L1 behaves like a tax, not a workload

A workload is finite. You can burn it down. A tax is structural — it's levied on something you can't stop doing, it recurs on a schedule, and the rate is set by factors outside your control.

Tier 1 volume passes every part of that test. It's levied on having employees, devices, and SaaS apps — none of which you'd give up to lower the bill. It recurs continuously: a typical knowledge-worker org generates around four IT tickets per employee per year, 60–80% of them routine Tier 1. And the rate is set by company growth, not by how well your help desk is run. Add 100 employees and you've added roughly 400 tickets, ~250 of them Tier 1, before anyone files a single one.

That's why "we just need another L1 hire" never ends the conversation. The hire clears this quarter's backlog and the tax base keeps expanding underneath it. You haven't lowered the tax. You've funded a slightly bigger collection office.

The tax stack: where the money actually goes

A tax has a formula. So does this one. The annual L1 tax on an IT organization is the product of four layers, each one multiplying the one below it:

   ticket volume        (how many L1 requests land per year)
×  handle time          (engineer-hours per ticket, end to end)
×  burdened rate        (fully-loaded cost of those hours)
×  annual compounding   (every year, scaling with the org)
─────────────────────────────────────────────────────────────
=  the L1 tax

Run it for a 500-person org. Around 1,200 of its ~2,000 annual tickets are Tier 1. At a published industry benchmark of roughly $25 in operational cost per Tier 1 contact, that's $30,000 a year on the invoice — the visible layer.

But handle time and burdened rate hide the larger layers underneath. Each ticket also costs the user their wait time (hours of not doing their job) and costs the engineer the interruption — context-switching between deep work and a reactive queue measurably cuts technical output by 20–40%. Loaded for those, the real cost of a Tier 1 ticket runs 3–5x the invoice number. The $30,000 visible tax is really $90,000–$150,000 once you count the layers finance never sees.

And the bottom layer — annual compounding — means you pay it again next year, larger, because the org grew. That's the stack the diagram below makes concrete.

Why the usual fixes only adjust the rate

Most "L1 strategies" are rate adjustments. They make each unit of the tax a little cheaper without changing the fact that you're paying it on every ticket.

Hiring lowers per-ticket wait time by adding throughput, but it raises the burdened-rate layer and does nothing to volume or compounding. Self-service portals shift some volume to the user — useful, but credit and effort move to the employee, and self-service password reset typically covers only the simplest half of the password queue. Chatbots and copilots lower apparent volume by answering or suggesting, then hand the actual execution back to a person or a portal. Containment goes up; the work, and its loaded cost, still gets finished downstream.

Each of these is a smaller percentage of the same base. None of them removes the base. You're still paying L1 on every ticket — just at a marginally better rate. A tax you've negotiated down is still a tax.

The only move that stops the payment: remove the work

You stop paying a tax on something by no longer doing the taxed thing. For L1, that means the ticket never becomes a unit of human work in the first place.

That's a different mechanism from deflection, and the difference is the whole point. Deflection relocates a ticket — to an article, a queue, a better-formatted handoff. Removal eliminates it. The mechanism is an autonomous engineer that, for each incoming request, investigates the M365 environment to find the real cause, plans the exact change required, and executes it against the live backend — Entra ID, Exchange Online, SharePoint, Intune — under an explicit policy, with a full audit trail. No ticket lands in a human queue, because the work is already done.

This is what Dex Go does inside Microsoft Teams and Slack: an employee describes the problem in plain language — locked account, lost MFA, missing SharePoint access, a device that won't behave — and Dex resolves it end-to-end, scoped to that user's own account and nothing else. On the L1 surface, that runs at a 90%+ end-to-end resolution rate. The ticket isn't deflected. It's gone.

Critically, this is not an L1-only mechanism. The same investigate-plan-execute loop resolves L1 through L3 — the deeper Tier 2 and Tier 3 troubleshooting, configuration, and engineering-adjacent work that used to demand a senior tech. L1 is simply where the tax is heaviest by volume, which is why it's the first layer to remove. Only genuine architecture and judgment calls escalate to a human, and they arrive with full context attached.

What removal does to the tax stack

Go back to the formula. Removing the work doesn't trim one layer — it knocks out three at once.

Volume collapses on the routine surface: 90% of those 1,200 Tier 1 tickets never reach a person, leaving ~120 genuine escalations. Handle time for that 90% drops to effectively zero engineer-hours, because no engineer touches them. Burdened rate stops applying to work that no human performs. The only layer left standing is annual compounding — and it's now compounding against a fraction of the base.

The invoice line shrinks modestly. The loaded cost — the user wait time and engineer interruption stacked on top — collapses, because those layers were never on the invoice to begin with. That's the recovered output the help desk math points to: most of the savings live in every other team's productivity and in your senior engineers' reclaimed calendar, not in a smaller help desk budget.

Cliff DuPuy, Director of IT at Grand Traverse County (an MSP), put a number on the calendar side: "Dex helped us unlock $67K in value in a single day." That wasn't a discount on the tax. It was the work his team got to do once the queue stopped owning their attention.

What to do Monday

Three moves turn this from a frame into a plan:

1. Re-file L1 under "tax," not "staffing," in the budget conversation. The question stops being "how many more L1 hires do we need?" and becomes "how much of this base can we remove?" That reframe alone changes which solutions look serious.

2. Audit your current L1 spend for rate-adjustments masquerading as fixes. Anything that improves containment, deflection, or self-service is lowering the rate, not the base. Useful, but don't mistake it for stopping the payment.

3. When you evaluate an agentic IT tool, ask for end-to-end resolution rate on the L1 surface — and confirm it covers L1 through L3. A tool that only "handles Tier 1 chat" is a rate adjustment with better marketing. One that investigates, plans, and executes the real change is the only thing that removes the base.

L1 isn't expensive because your team is slow. It's expensive because it's a tax — structural, recurring, compounding — and you've been told the only options are to pay it faster or pay it cheaper. There's a third option. Stop generating the thing that gets taxed.