Guides

Run Monitoring for Your Clients

A practical guide for agencies and MSPs: onboard clients in minutes, route alerts per client, present white-label status pages, and prove your SLA every month.

Overview

If you run websites or applications for clients, monitoring is part of the service whether it is on the invoice or not. This guide walks through the full client lifecycle on Uptimy: standing up monitoring for a new client, keeping clients organized as you grow, presenting status under your own brand, proving your SLA every month, and handling day-to-day operations like maintenance windows and incident communication.

Everything runs in a single workspace shared by your whole team: one dashboard, one on-call rotation, every client visible at a glance. There is no context switching between client accounts, and any team member can see the state of every client immediately. If a client contractually requires hard isolation, the Enterprise plan offers multiple workspaces.

The Scale plan is built for this workload: 100 healthchecks, 25 team members, 15-second check intervals, 50 heartbeats, browser (Playwright) checks, white-label branding with custom domains, 5 public status pages with 250 subscribers each, unlimited private status pages, premium workflow nodes (SMS, WhatsApp, Railway self-heal), and 90-day log retention. That is enough headroom to run monitoring for dozens of clients from one place.

Onboard a Client in Minutes

The fastest way to onboard consistently is to treat monitoring as code. Keep a workspace file per client in your repo, with the client's monitors, status page, alert and report, and apply it with uptimyctl. Every client gets the same baseline coverage, and onboarding stops depending on someone remembering to click through the dashboard.

acme.yaml
version: 2
monitors:
  - name: Acme - Marketing site
    target: https://www.acme-client.com
    tags: ["client:acme"]
  - name: Acme - API
    target: https://api.acme-client.com/health
    tags: ["client:acme"]
  - name: Acme - Certificate
    type: ssl
    target: www.acme-client.com
    tags: ["client:acme"]
statusPages:
  - name: Acme Status            # private until you add public: true
    groups:
      - name: Services
        monitors: [Acme - Marketing site, Acme - API]
alerts:
  - name: Acme incidents
    to: { emails: [acme-oncall@your-agency.com] }
    tags: ["client:acme"]
reports:
  - name: Acme
    tags: ["client:acme"]
    sla: 99.9
    timezone: America/New_York
    emails: [cto@acme-client.com]
    brand: { name: Acme Corp, color: "#0055ff" }

plan shows what applying the file would add or change, and apply does it. Tags the file uses are created for you.

onboard-client.sh
# Authenticate (API keys start with upt_)
export UPTIMYCTL_API_KEY=upt_your-api-key

# Review, then apply the client's file
uptimyctl plan -f acme.yaml
uptimyctl apply -f acme.yaml

Everything is matched by name, so applying the file again changes what you edited and adds nothing twice. What the file doesn't name is kept, so other clients are never touched. Don't pass --prune with a per-client file: it would remove every other client's monitors, status pages, alerts and reports. uptimyctl export -f uptimy.yaml writes the whole workspace to one file, a reviewable snapshot that works as a backup and as a way to audit what is monitored for whom.

Organize and Route Per Client

As the client count grows, structure is what keeps the dashboard readable and alerts landing in the right place.

  • Monitors: each monitor watches one thing (in the API, an application holds exactly one healthcheck). Start each name with the client, like Acme - API, so the list reads by client.
  • Tags: tag every monitor and heartbeat with the client it belongs to. Tags are how monitors are grouped: they drive dashboard filters, alert routing and per-client reports.

Use Tags as the Client Boundary

Adopt a consistent tag convention like client:acme on every monitor and heartbeat that belongs to a client. One tag then answers "what do we run for Acme?" in dashboard filters, alert routing and the client's report. Status pages list their monitors by name, so add the client's monitors to their page.

Routing happens in workflows. Filter nodes match on severity, source, tags, or specific resources, so each client's incidents can flow to that client's dedicated Slack channel, an email distribution list, or the internal account owner — while everything else goes to your general on-call channel. Deduplicate and Delay nodes keep flapping checks from spamming anyone, and on-call schedules resolve who the current responder is so escalation always reaches a human. On Scale, premium workflow nodes add SMS, WhatsApp, and Railway self-heal actions to the toolbox.

Present Under Your Brand

Give each client their own status page showing only their services. Branding covers your logo (light and dark variants), favicon, brand colors, company name and a custom font. White-label hides the sticky Uptimy bar; a small "Powered by Uptimy" stays on every page. The page your client sees is your product.

Custom domains complete the picture. For status.client.com, the client adds a TXT record at _uptimy.status.client.com with the value uptimy-verification=<token> the app shows, then a CNAME record pointing status.client.com to domains.upti.my. SSL is provisioned and renewed automatically. No certificates to manage, per client or otherwise.

The Scale plan includes 5 public status pages, each with up to 250 email subscribers (double opt-in, so lists stay clean). Password-protected private pages are unlimited: they use a shared password with rate-limited verification, and viewers do not need an Uptimy account. That makes private pages the natural default for every client beyond your public-page quota — reserve the public pages for clients who want a fully public status site with subscriber notifications.

Prove Your SLA Every Month

The recurring question from every client is the same: did you hit the SLA? SLA reports answer it with a link instead of a spreadsheet. Create a report per client that covers that client's monitors, with the SLA target from their contract, their logo and accent color, and a monthly or quarterly schedule in their timezone. Each period is frozen when it closes and emailed to the client's recipients, so what they received never changes afterwards.

For anything in between, share a link at app.upti.my/reports/{token} from the report's Share & export menu. A link covers a past week, month or quarter, or a range of days; a week, month or quarter still in progress can't be shared. It keeps the monitors it was created with, can expire after 7, 30 or 90 days, and can be deleted at any time: offboard a client, delete the link. The page prints to a clean A4 PDF for clients who want a document attached to the invoice.

Shared reports show the full report, incidents and their causes included, without links into your workspace. Planned maintenance is listed separately and doesn't count as downtime.

Operate: Maintenance and Incident Communication

When you deploy for a client, schedule a maintenance window for that client's monitors and show it on their status page. It starts and completes on its own at the times you set. Checks keep running and recording data, but alerts for those monitors are held back, the client's status page shows the maintenance, and its subscribers are told when you schedule it. Planned work never pages your on-call and doesn't count as downtime in the client's SLA report.

Maintenance windows are automatable, so your deploy pipeline can open one before it ships. --services lists the monitors whose alerts are held back (UUIDs from uptimyctl applications list), and --status-page the page that shows the window (from uptimyctl status-pages list).

maintenance-window.sh
uptimyctl maintenances create \
  --title "Acme Corp - platform upgrade" \
  --description "Scheduled platform upgrade for Acme production services" \
  --start-at "2026-09-01T02:00:00Z" \
  --finish-at "2026-09-01T04:00:00Z" \
  --services '[{"uuid":"<acme-api-uuid>","name":"Acme - API"},{"uuid":"<acme-site-uuid>","name":"Acme - Marketing site"}]' \
  --status-page <acme-status-page-uuid>

When something does break, incident communication runs through the same per-client channels you set up earlier: the workflow posts to the client's Slack channel or email, and their status page shows the affected service's state. Publish the incident on their page to show it there; its subscribers then hear about it and about every public update. Your team works the incident from the shared dashboard while each client sees only their own picture.

Where to Go Next

Dig into the pieces this guide is built on: the uptimyctl CLI for onboarding as code, status pages for white-label branding and custom domains, and SLA reports for client-ready uptime reporting.