For a texting feature, set three service level objectives: how fast the SMS API accepts your request, what share of accepted texts reach the phone, and how far behind your handling of delivery status webhooks runs. The first and third are yours to engineer. The second depends on carriers, so you set a target and watch it rather than promise it.

Every number in this post is an assumption for a worked example, not a benchmark and not a Ready commitment. Replace them with your own measurements after a few weeks of data.

Why a texting feature needs its own SLOs

A general "API availability" target hides the failures users notice. A text can be accepted instantly and never arrive. A delivery webhook can land an hour late and leave your UI showing "sending" for a message the phone already received. Splitting the feature into stages gives each its own number and its own owner.

The stages are: your request reaches the API and is accepted, the message is handed to the carriers and delivered, and the status comes back to you. Our guide to SMS delivery rate monitoring for platforms goes deeper on the middle stage.

The three SLIs and example targets

An SLI is what you measure. An SLO is the target for it over a window. These targets are assumptions for a mid-size product.

SLIHow to measure itExample target (assumed)
Accepted-by-API latencyTime from your request starting to a 2xx coming back, at the 95th percentile95% of sends under 1 second over 30 days
Acceptance successSends answered 2xx, divided by sends answered 2xx or 5xx or timeout99.5% over 30 days
Delivery rateTexts reported delivered, divided by texts accepted, with exclusions belowSet after 4 weeks of your own data
Webhook lagTime from the status change to your handler finishing, at the 95th percentile95% within 60 seconds

Two of these need care.

Acceptance success should leave out refusals that are working as designed. A 4xx for an opted-out number or a missing consent attestation means your guardrails worked, not that the service failed. Count only the failures you'd page someone for: 5xx, timeouts and 429s you didn't expect.

Delivery rate is the one you can't fully control. Carrier filtering, bad numbers and landlines all lower it. Exclude numbers that were refused up front, and segment the metric by number or campaign so a single bad sender doesn't hide behind a healthy average. We deliberately don't suggest a universal target, because there's no honest benchmark to borrow; measure your own baseline first.

Do the error budget math

An error budget is the failure you can afford. A 99.5% target over 30 days means 0.5% of requests may fail.

Worked example, with assumed volume of 100,000 sends in 30 days:

  • Budget: 100,000 × 0.005 = 500 failed sends.
  • If a bad deploy of your own makes 200 sends fail on one afternoon, you've spent 40% of the month's budget.
  • If you've spent 80% by day 12, you slow risky releases and spend the time on retries and timeouts instead of features.

That second bullet is the point. A budget turns "should we ship this on Friday" into arithmetic. For the retry work that stretches it, see SMS API retries and failure handling.

Note that a retried send that succeeds on the second attempt with the same Idempotency-Key counts as a success for the user. Decide whether your SLI counts per request or per message, and write it down. Per message is closer to what the customer sees.

Measure webhook lag honestly

Webhook lag has two halves: how long the status takes to reach you, and how long you take to process it. You can only fully observe the second half. Record the time your endpoint received each delivery status webhook, and the time your handler finished. If your endpoint acknowledges fast and works later, as described in fast-ack webhook endpoints, the finish time is the one that matters for your UI.

Don't build the SLI on ordering. Statuses can arrive out of order, so track lag per message and see out-of-order webhooks and event ordering. If a webhook never arrives, your reconciliation job reading GET /v1/messages is the backstop, and its own lateness belongs in the same SLI.

Alert on burn rate, not on single failures

One failed send isn't an incident. A fast burn is. A common pattern, using assumed thresholds:

  1. Page when the budget is burning fast enough to be gone in a day (for example, a short window where the failure rate is many times the allowed rate).
  2. Open a ticket when it's burning fast enough to run out in a week.
  3. Review the rest weekly, with no alert.

Pair these with the logging in SMS API observability, logging and alerting so the alert links to the failing requests. Redact phone numbers and message bodies from what you log.

What belongs outside the SLO

Some events are policy, not reliability, and shouldn't burn the budget:

  • A text held or refused for quiet hours, which the API answers with 409 QUIET_HOURS_BLOCK when the window is too far off.
  • A refusal for an opted-out or Ban-listed number, which isn't charged.
  • A prepaid balance running out, which you can alert on separately.

Keeping these in a separate "refused by policy" counter makes your delivery numbers cleaner and gives product a view of how often guardrails fire.

Takeaways

Pick three SLIs, label your first targets as assumptions, and revise them after a month of real data. Spend the error budget on purpose. For the request details your latency SLI measures, see the messages API docs, and to test your numbers against a real account, sign up and run a small load.