Behind your team, invisible to your clients.
The clearest way to show how coverage works is to walk one covered night from start to finish: how the alert reaches us, what we're allowed to touch, who hears from us and who never does, and how the night hands back to your team. No mystery, no seams.
Invisible, or disclosed. Your choice, per client.
Invisible Most partners start here
We work behind your team, inside your ticketing and your Slack, and everything we produce goes to you, never to your clients: they never meet us, never email us, never need our number. The night simply looks like your agency handled it. NDA standard.
Disclosed Your operations partner
Prefer it in the open? Introduce us as your operations partner: same engineers, same guardrails, under our own name, with the client relationship and the billing staying yours. We publish no prices anywhere, so what you charge your client is yours to set. Your call, client by client.
Either way, your clients stay yours: we never approach them, and if one of them ever comes to us, we turn the work down and send them back to you. It's in the contract.
An alert fires. It routes to us, not your lead developer.
Every covered night starts the same way: something breaks, and the page comes to us instead of your team. How it reaches us depends on what you already run.
You already have monitoring
We join your existing setup as the escalation layer for the hours you can't staff. Connecting is simple: point your alerts at a dedicated email address we give you, or we ingest directly from CloudWatch and SNS, Datadog, New Relic, Grafana, Prometheus, PagerDuty, Splunk, Nagios, and Zabbix. No agents, no duplicate stack, no re-instrumenting. And if what you run isn't named here, we're flexible.
Your client has no monitoring
If you want us to bring the stack, we deploy it into the client's cloud account, as code, in a repository they control. Dashboards live at their URL, alerts route to us, and it all keeps working if we ever part ways. Optional, per client.
Or run both where it helps: keep what a client already has, and we fill the gaps. Our own stack watches every layer, databases to backups, with checks matched to what each client runs, most on a three-minute cycle.
Within 15 minutes, a real engineer is engaged.
A fast-response promise is easy to make and easy to automate. Ours is specific and in writing: we begin responding to critical alerts within 15 minutes, a real engineer engaged, not just an auto-acknowledgement. We respond to tickets within 30 minutes during covered hours. It's backed by a written SLA, with custom SLAs available, so you can sign coverage promises to your clients that we've signed to you first.
- The 15-minute commitment doesn't hang on a single notification. An unanswered critical page fires again at five minutes; at ten, a second engineer is pulled in. It holds through a phone on silent, a dead battery, or a rough night.
The guardrails are on screen.
One page per client: what we may do, what wakes you, what waits for morning. The engineer works from the guardrails and escalation rules agreed for that client: fix what they allow, call who they name, never guess. We draft the guardrails with you during onboarding and update them with you after every major incident. The examples below are typical; where each item lands is set by the guardrails we agree for each client.
Handled without a call
- Clearing a filling disk
- Restarting a stuck service
- Adding capacity under load
Always a call first
- Failing over a database
- Changing production config
- Restoring from a backup
Fixed, inside your systems.
Within the guardrails, we handle it, and everything we produce lands where your team already works. We work the ticket in your ticketing system, Zendesk, Freshdesk, Jira, ConnectWise, or a shared inbox, so the night's record lives where your team lives, and we keep our own internal incident log as the record behind the SLA. One shared Slack channel with your team is watched around the clock, with anything critical riding the paging pipeline so nothing urgent hides in a thread. And your staff get a 24/7 number that pages the on-shift engineer for a fast callback; your clients never need our number.
Escalated your way. Handed back by morning.
Some incidents must reach your team, and the guardrails you define name which ones in advance. Four things always escalate to you, whatever the guardrails say:
- Privileged changes we can't make ourselves
- High-impact security incidents
- Anything past the severity threshold we agreed
- Repeated failures that need a developer or architect to fix
When we do wake someone, we wake exactly who you told us to wake, with the timeline, the metrics, and what we already tried. Not a screenshot and a question mark.
And when your covered hours end, your day team sees the whole night in the ticket: every action we took and how it ended, with the engineer's name signed to it. Your day shift works exactly as it does now; the night just stops being anyone's second job.
Bring one client environment.
We document the environment, draft the client guardrails from your intake, wire the alert routing, and confirm access with a test your client can watch. Then add the next client whenever you're ready; the coverage grows with your client base. And if the way your agency runs doesn't match something on this page, say so: we'd rather fit how you work than make you fit us.
Day-to-day work per client stacks on whenever you want it: patching, backups and disaster recovery, security hardening, scheduled overnight changes. Same engineers, same guardrails, one partner invoice.
30-day money-back guarantee · No long-term contract, month-to-month · No setup fee · Add or remove client environments as your client base changes
See the guardrails drafted for your own client.
A 30-minute call and one client environment is all it takes to judge us properly. We'll draft the guardrails together and get that first environment covered.