Shared monitoring ownership between developers and operations is the fix for a familiar failure: the alert fires, the on-call engineer opens the dashboard, and nobody can say who wrote the check or what it was meant to catch. This article explains how to split monitoring ownership so developers own what their code should do and operations owns how the platform stays reachable. It also covers how to keep uptime checks, response time thresholds and downtime alerts from becoming orphaned the moment a team changes.
The payoff is fast. Alerts get routed to someone who can act on them, triage time drops and fewer checks quietly rot because “the other team handles that.”
Why Single-Team Monitoring Breaks Down
When operations owns all monitoring, the checks describe infrastructure: CPU, disk, whether port 443 answers. They rarely describe the business. A login endpoint can return HTTP 200 with an empty JSON body for six hours, and every server monitoring graph stays green.
When developers own all of it, the reverse happens. The application has detailed metrics in Prometheus or Datadog, but nobody watches DNS expiry, TLS certificate renewal or the load balancer health check. Those failures fall between teams because they belong to no codebase.
Neither team is careless. Each one monitors what it can see. Shared ownership exists to cover the blind spots between them.
A Practical Split of Monitoring Ownership
The cleanest model divides responsibility by question rather than by tool. Operations answers “is the site reachable and is the platform healthy?” Developers answer “does the feature behave correctly for users?”
In practice, the split usually looks like this:
– Operations owns: external HTTP monitoring of the main domains, SSL certificate validity, DNS, CDN and load balancer health, and host-level server monitoring.
– Developers own: keyword checks on critical pages, API endpoint checks, application error rates and response time budgets for the services they ship.
– Shared: alert routing rules, SLA monitoring targets and the post-incident review of every check that fired or should have fired.
The shared row is where most teams fail. Someone has to own the routing table itself, and in teams under 10 people that is usually one named person, not a committee.
How to Set It Up Step by Step
An experienced SRE starts with an inventory, not a new tool. Export every existing uptime check, alert rule and notification channel into one spreadsheet. A team of 20 engineers often finds 60-150 checks, and roughly a third of them have no clear owner.
Next, assign an owner to every row. The owner is a team, not an individual, so the check survives holidays and resignations. If nobody claims a check within a week, delete it. An unowned alert is worse than no alert, because it trains people to ignore notifications.
Third, put monitoring definitions next to the code. Teams using Terraform can manage Datadog monitors or Grafana alert rules as code, and a GitHub or GitLab CODEOWNERS file then forces the owning team to review any change. Developers who add a new endpoint add its check in the same pull request.
Fourth, wire alert routing to ownership. In PagerDuty or a similar tool, each service maps to an escalation policy. A failing checkout API pages the payments team first, not the platform on-call. Operations stays on the escalation path as a second tier for anything that looks like infrastructure.
Finally, review ownership quarterly. Thirty minutes is enough to check that every alert still has a living owner and that new services got coverage. Pairing this with a fair rotation matters – the guidance in building an on-call rotation that doesn’t burn people out applies directly once developers start carrying pagers.
A Scenario Most Teams Will Recognize
A mid-sized online store migrates its product API from a VM to a container platform on a Friday afternoon. The external HTTP check on the homepage stays green, because the homepage is cached by the CDN. Operations sees no problem.
The product API, however, now responds in 2.8 seconds instead of 300 ms because the new connection pool is undersized. Nobody gets alerted, because the only response time threshold lives on the old VM’s monitoring agent, which was decommissioned along with the VM.
Search conversions fall about 20% over the weekend. On Monday the developers find it in analytics, not in monitoring. The fix takes ten minutes. The gap lasted 64 hours, and it existed because the check belonged to infrastructure that no longer existed and to a team that no longer ran the service.
With shared ownership, the migration pull request would have included the new API check, reviewed by the developers who own the service.
Common Mistakes That Undermine Shared Ownership
Assigning ownership to people instead of teams. When the one engineer who set up the Grafana alerts leaves, the alerts keep firing to a deactivated email address. Route to team aliases or rotation schedules, never to personal inboxes.
Letting developers write alerts without paying for them. If developers create checks but operations gets paged, thresholds drift toward noise. The team that writes an alert should receive it first. That single rule fixes more alert fatigue than any tuning exercise.
Trusting internal metrics over external checks. An application can report itself healthy from inside the cluster while users get a 502 from an expired certificate or a misconfigured CDN rule. External uptime checks from outside your network remain the ground truth for site availability, and operations should own that outside-in view.
The Myth That “You Build It, You Run It” Removes Operations
The phrase, attributed to Werner Vogels at Amazon in 2006, is often read as “developers handle all monitoring.” That reading misses the point. Even teams that fully embrace it keep a platform or SRE group that owns shared infrastructure, monitoring standards and the external view of website performance.
The edge cases make this obvious. Regulated industries such as banking or healthcare often need separation of duties, so the developer who deploys code cannot be the only one who validates its availability. In on-prem or air-gapped environments, developers may have no access to production hosts at all. Shared ownership adapts to those constraints. Pure developer ownership does not.
FAQ
Who should own SSL certificate and domain monitoring?
Operations or the platform team, in almost every case. Certificates and domains span many services, and a single expiry can take down every application at once, so they need one owner with an organization-wide view.
Should developers be on call for their own services?
Yes, for application-level alerts, as long as operations remains the escalation tier for infrastructure. Start with business hours only and expand once alert volume is below two or three pages per week.
How do small teams handle this with only 3-5 engineers?
Skip the formal split. Keep one shared list of checks with a named owner per row, review it monthly and make the developer who ships a feature responsible for adding its check.
Making Ownership Stick
Monitoring ownership works when every check has a team behind it, every alert reaches the people who can fix it and every new service ships with its own coverage. Operations owns the outside-in view of availability. Developers own the behavior of their code. Both own the routing and the review.
The most useful habit is simple: after every incident, ask which check should have caught it and who owns that check now. Building that question into your post-mortem process turns each outage into one fewer gap in coverage.
