SLA credit calculation and enforcement workflow with worked examples

Most agency SLAs read fine on paper. "99% dashboard uptime." "48-hour response on priority tickets." "Reports delivered by the 5th." Then something breaks, a client gets annoyed, and the account manager panics and offers a random discount to smooth things over. No formula, no evidence trail, no consistency. Next quarter a different client hits the exact same miss and gets nothing, because a different AM handled it.

That inconsistency is the real problem. Not the breach itself — breaches happen. The problem is that credit decisions get made emotionally, in the moment, based on how loud the client is and how nervous the AM feels. You end up over-crediting calm clients who wouldn't have churned anyway, and under-crediting the ones actively shopping around.

This piece walks the full path: detecting a breach, capturing evidence, calculating the credit with real numbers, notifying the client, and pushing it through billing. Plus dispute rules and copy-ready templates so your team stops improvising.

Why credit decisions go sideways

A few patterns keep coming up when agencies handle SLA credits badly.

The SLA has no measurement definition. "48-hour response" — response measured from when? Ticket creation? First business hour? Does the weekend count? If the contract doesn't define the clock, every breach becomes an argument. The client says you were 12 hours late; you say you were on time because Saturday doesn't count. Neither side can prove it.

Nobody logs the breach when it happens. By the time the client complains three weeks later, the Slack thread is buried, ticket timestamps are fuzzy, and your AM is reconstructing events from memory. You can't calculate a defensible credit from memory.

Credit percentages aren't tied to severity. A five-minute dashboard blip and a missed monthly report get treated the same because there's no tiered schedule. So the AM guesses.

The fix isn't a stricter contract. It's a repeatable workflow that turns a breach into a number the same way every time, regardless of who's handling the account. This connects directly to how you've structured your service tiers and billing-linked capacity — if your SLOs aren't tied to what clients actually pay for, credits get messy fast.

The five-stage workflow

Each stage produces an artifact the next stage depends on.

1. 1
   1. Breach detection → produces a timestamped breach record
2. 2
   2. Evidence capture → produces a locked evidence bundle
3. 3
   3. Credit calculation → produces a dollar figure with the formula shown
4. 4
   4. Client notice → produces a sent notification with the credit stated
5. 5
   5. Billing execution → produces an applied credit on the invoice

The important rule: you don't skip forward. No calculation without evidence. No notice without a calculation. No billing without a sent notice. When AMs jump straight from "client is mad" to "here's 20% off," that's where inconsistency starts.

Visual overview of the workflow:

Stage 1 — Breach detection

1. 1
   Metric

   Monthly performance report delivery

2. 2
   Target

   Delivered by end of day on the 5th business day of the month

3. 3
   Measurement window

   Calendar month

4. 4
   Exclusions

   Client-caused delays (missing access, late approval of data sources)

The exclusion line matters more than people think. A lot of the "breaches" in real operations are actually client-caused — you couldn't pull the report because they never granted access to the new GA4 property. If your SLA doesn't carve that out, you'll be crediting yourself for their delays.

Stage 2 — Evidence capture

The moment a breach is flagged, freeze the evidence. What goes in the bundle depends on the SLA type:

The evidence bundle needs to be locked — meaning nobody edits timestamps after the fact. If your evidence lives in a spreadsheet that three people can change, it's not evidence, it's a story. This is the same discipline behind reporting built on KPI governance: the numbers have to be defensible, not just presentable.

Stage 3 — Credit calculation with worked examples

This is where most agencies wing it. Don't. Use a tiered percentage schedule tied to the affected service fee, and calculate pro-rata when the breach only affects part of a period.

Worked example 1 — Percent credit on a missed report.

A client pays a $6,000/month retainer. Reporting is broken out as 15% of the retainer, so the affected service fee is $900. The monthly report was delivered 30 hours late with no client-caused delay. That's a Major breach at 20%.

1. 1
   Affected service fee

   $6,000 × 15% = $900

2. 2
   Credit

   $900 × 20% = $180

Not $180 off the whole retainer. $180 off the reporting component. That distinction keeps credits proportional and stops a single missed report from wiping out your margin.

Worked example 2 — Pro-rata dashboard downtime.

A client on a $4,500/month retainer has a live dashboard priced internally at 10% of the retainer = $450/month. The dashboard was down for 14 hours in a 30-day month.

1. 1
   Total service hours in month

   30 days × 24 = 720 hours

2. 2
   Downtime

   14 hours

3. 3
   Pro-rata downtime fraction

   14 / 720 = 0.0194 (roughly 1.94%)

Then apply severity. 14 hours is Major (over 8 hrs), so 20%:

1. 1
   Pro-rata affected fee

   $450 × 1.94% = $8.73

2. 2
   Apply severity multiplier...

Here's a decision you have to make and write down: do you credit pro-rata by time OR by severity tier, not both stacked randomly. Two clean methods:

Method A (severity-based): $450 × 20% = $90 credit. Simple, flat by tier.

Method B (pro-rata time-based): You refund the exact fraction of service lost: $450 × 1.94% = $8.73 credit. Precise, but tiny — and clients feel insulted by a $9 credit for a full-day outage.

Most agencies land on severity-based with a pro-rata floor — use the tier percentage, but if the pro-rata number comes out higher than the tier, the client gets whichever is larger. That protects clients on genuinely long outages without giving away money on minor blips. Pick one method, put it in the contract, and stop renegotiating it per incident.

Stage 4 — Client notice

Send the notice before the client asks. Proactive credits build more trust than the credit amount itself. The template:

--- Subject: Service credit applied — [Month] [SLA item] Hi [Name], During [period], we didn't meet our committed service level on [specific deliverable]. Here's what happened and what we're doing about it. What happened: [One-sentence factual summary. E.g., "Your monthly performance report was delivered 30 hours after the committed deadline of the 5th business day."] Root cause: [Brief, honest cause. No blame-shifting.] Credit applied: Per your service agreement, this qualifies as a [severity] breach. We've applied a credit of $[amount] to your next invoice, calculated as [X]% of the affected [deliverable] fee. Prevention: [One concrete step you've taken so it doesn't recur.] If any detail here looks off, reply within 10 business days and we'll review the evidence together. [Your name] --- The 10-business-day reply window is your dispute clock. Without it, disputes reopen indefinitely.

Stage 5 — Billing execution

The credit isn't real until it's on an invoice. The failure mode here is embarrassing: AM promises a credit, tells the client, and then it never gets applied because it lived in an email and never reached whoever runs billing. Now you've broken a second promise on top of the first.

The handoff needs a closed loop: credit approved → logged against the specific invoice → confirmation back to the AM that it's applied. If billing and account management run in separate tools that don't talk to each other, this is exactly where credits disappear.

Dispute rules that actually resolve things

Write these into the SLA so disputes don't turn into open-ended arguments:

1. 1
   Disputes must be raised within 10 business days of the credit notice
2. 2
   The client must specify which evidence they're contesting
3. 3
   Ties go to the documented timestamp, not memory or email recollection
4. 4
   Client-caused delays are excluded and must be documented at the time, not claimed retroactively
5. 5
   Maximum total credits per month are capped (commonly 50–100% of the affected service fee, never the full retainer)

That last cap matters. Without it, a genuinely bad month could theoretically wipe your entire retainer, and no agency survives operating that way. Cap it, disclose the cap, and everyone knows the ceiling going in.

A real scenario

A mid-size agency running around 40 retainer clients kept eating unstructured credits. Their AMs handed out discounts to keep nervous clients happy — no schedule, no evidence, no cap. Over a quarter, those ad-hoc concessions ran somewhere in the $9k–$11k range, and nobody could tell you which credits were actually justified.

They put in a defined schedule, an evidence-capture step, and the 10-day dispute window. Next quarter, the number of actual breaches was roughly the same — but credits dropped to around $4k, because calculations were now proportional to the affected service component instead of the full retainer. And oddly, client complaints about "you never own your mistakes" went down, because the proactive notices showed clients the agency was catching and pricing its own misses.

The number that dropped wasn't breach count. It was the money leaking out through guesswork.

When rigid credit enforcement makes sense — and when it doesn't

It makes sense when you have enough clients that inconsistency is real money, your SLAs are contractually defined, and your AMs are improvising credits without oversight. If random discounts are flying out to keep people happy, you need the structure yesterday.

It's a bad idea when you have a handful of high-touch clients where relationship judgment beats formula. For a boutique shop with six enterprise accounts, a rigid schedule can feel bureaucratic. A lighter framework — evidence capture and a reasonable credit range — works better than a strict percentage table.

Who should skip most of this: project-based agencies with no ongoing SLAs. If you're not committing to uptime, response times, or recurring delivery windows, there's nothing to credit against. Build the workflow when you move to retainers, not before.

Making the workflow stick

The schedule and templates are the easy part. The hard part is making detection and evidence capture happen at the moment of the breach, not weeks later from memory. That's usually where an operational platform earns its keep — flagging a missed delivery window against the defined SLA, locking timestamps into a record that can't be edited after the fact, and routing the calculated credit to billing so nothing gets promised and then forgotten.

The point isn't automation for its own sake. It's closing the two failure points that cause every messy credit situation: missing evidence and a broken handoff to billing. Get those two right and SLA credits stop being a source of anxiety. They become a small, predictable, honest line item — one that quietly proves to clients you hold yourself to the same standard you sold them.

“

Lock timestamps into a read-only evidence bundle when you flag a breach to avoid post-hoc edits.

The point isn't automation for its own sake. It's closing the two failure points that cause every messy credit situation: missing evidence and a broken handoff to billing. Get those two right and SLA credits stop being a source of anxiety. They become a small, predictable, honest line item — one that quietly proves to clients you hold yourself to the same standard you sold them.

The point isn't automation for its own sake. It's closing the two failure points that cause every messy credit situation: missing evidence and a broken handoff to billing. Get those two right and SLA credits stop being a source of anxiety. They become a small, predictable, honest line item — one that quietly proves to clients you hold yourself to the same standard you sold them.