Tenant Separation: Keeping Client A from Seeing Client B
Here is the phone call nobody wants. A client's IT manager opens the status page you built for them and sees a server that is not theirs. The hostname is from a company across town, which is another of your clients. Or a Monday-morning alert email about one client's firewall lands in another client's inbox. Nothing was hacked. Nobody did anything malicious. A checkbox was in the wrong state. In thirty seconds you have gone from "trusted provider" to "we need to talk about our contract." I have taken a version of that call. It is short, and the silence in it is long.
When you monitor several clients from one platform, each client is a tenant. This is a compartment of devices, users, history, and notifications that must stay sealed from the others. The mechanics of building those compartments — tags, groups, scoped views, alert routing — are covered in Multi-Tenant Monitoring, and this guide will not repeat them.
This guide is about the service side of separation. What you are actually promising a client. Who is allowed to see what. It covers where leaks happen in the parts of the platform everyone shares and what belongs in the contract. It also explains how to prove to a client or an auditor that the promise is kept. And it covers how to remove a client so cleanly that nothing of theirs is left behind. None of it is difficult. All of it is the kind of work that gets skipped on a busy Tuesday, which is when the checkbox ends up in the wrong state.
In this guide
- What you are actually promising
- Access roles, from the service side
- Reports and notifications: the misdirected email is a breach
- Naming that prevents cross-client mistakes
- Shared surfaces that leak
- Write it down: the contractual expectations
- Proving separation to a client or an auditor
- The separation checklist
- Offboarding a client cleanly
- Where to go next
What you are actually promising
Strip away the technology and the promise is short: their data, only their data, only to the people they approved, for as long as agreed. Each clause is a separate obligation, and it helps to name them, because each one fails in a different place.
- Their data. Everything you collect about their devices belongs to them in the sense that matters. They can see it, ask for it, and ask you to delete it.
- Only their data. Nothing from any other client is visible to them, in any view, report, message, export, or screenshot. This is the clause the phone call is about.
- Only to approved people. Their own staff, the technicians on your side who serve them, and nobody else. "Nobody else" includes your other clients, your former staff, and the sales person who wants a screenshot.
- For as long as agreed. History is kept for a defined period, and when they leave, it is returned or destroyed on a date, not forgotten on a disk.
Monitoring data looks harmless compared with a database of customer records, and that is exactly why it leaks. But a device inventory tells a competitor what a company runs. A bandwidth graph reveals when the office is empty. And an alert history reveals which systems are fragile. Treat it as confidential because your client already does.
Access roles, from the service side
Roles are how the "only to approved people" clause becomes enforceable. The principle is that every login is scoped by default and widened only on purpose. A useful set of roles for a client-serving platform looks like this, regardless of what your tool calls them.
| Role | Who holds it | Can see | Can change |
|---|---|---|---|
| Client viewer | Client staff who want status | Their own dashboards, availability, recent incidents | Nothing |
| Client contact | The client's IT lead | As viewer, plus their alert history and reports | Their own notification preferences, if you allow it |
| Assigned technician | Your staff serving that client | Every device and check for the clients they are assigned to | Acknowledge, tune thresholds, add devices within those clients |
| Senior technician / on-call | Your escalation staff | All clients | As technician, across all clients; no user or role changes |
| Platform administrator | Two or three named people | Everything | Everything, including roles, tenants, and integrations |
Three practices matter more than the exact role names. First, scope technicians per client where your tool allows it, even though "everyone sees everything" is easier. A technician who serves four clients should see four; the day they leave, four sets of access are revoked rather than one master key. Second, keep the administrator group tiny and named. Third, give every client login a real, named person on the client side. A shared "client@" login with a password on a sticky note is not a scoped account; it is a public one with extra steps.
Decide, too, who on the client side may approve access. New viewer accounts are requested by a named client contact, not by whoever emails you. A request from an unfamiliar address gets a phone call before it gets a login. Write the approver's name into the client's record, and when that person leaves the client, treat every account they approved as due for review.
Reports and notifications: the misdirected email is a breach
Dashboards get most of the attention. But the two channels that leak most often are the ones that leave the platform on their own: scheduled reports and alert notifications. A report sent to the wrong distribution list delivers one client's data into another client's mailbox with no login required. So does an alert rule whose recipients include a contact from another tenant. Treat a misdirected message as what it is: a data breach, small, but real, and one you must tell the affected client about.
Brightwater IT built its monthly availability report once, as a template, and cloned it for each new client. The clone for Northgate Retail kept the device filter from the client it had been copied from, Harbourview Clinic. So for two months Northgate's operations manager received a tidy PDF listing the uptime of HVC-DC01, HVC-FILE01, and an imaging server. The mistake surfaced when the clinic's IT lead asked why her report had a retail chain's till servers on page three. The clone had gone both ways. The review described the two reports as "cross-populated". Both clients were told. Both reports were rebuilt from the client's group rather than a copied filter. Every report Brightwater sends now carries the client code in the subject line and the footer.
The safeguards are procedural more than technical. Every client has exactly one distribution list for reports and one contact group for alerts. A distribution list is a single address that fans mail out to a fixed set of people. Both the list and the group are named with the client's code and owned by one person on your side. Recipients are never typed into an individual rule; rules reference the group. Before any new report goes live, send it to yourself first and read it as if you were the client. Does anything on the page belong to someone else? Global reports — "all sites overview," "all clients availability" — are internal-only and are never scheduled to an external address. And where your tool supports it, put the client's name in the subject line of everything it sends. That way, a misdelivered message is at least plainly misdelivered rather than quietly filed.
Tip: when it happens — and over enough years it will — do not quietly recall the message and hope. Tell the client whose data went astray. Tell the client who received it and ask them to delete it. Write down what happened and what you changed, and keep that note. The note is also what an auditor will ask for later. And "we caught it, disclosed it, and fixed the process" is a far better answer than silence.
Naming that prevents cross-client mistakes
Two clients both have a server called DC01. So do most of your other clients. Inside the platform, tags and groups keep them apart, but humans do not read tags. They read names in ticket titles, alert subjects, chat messages, and the credential vault. The vault is the password manager where your team keeps device secrets. Cross-client mistakes are almost always naming mistakes. For example, a technician restarts the right service on the wrong client's DC01. Or they paste one client's SNMP community string into another client's probe. A community string is the password-like string that lets a poller read a device over SNMP.
The rule that prevents most of it is simple: no bare names anywhere a human reads them. Every client gets a short code. The code prefixes everything that belongs to them — devices, dashboards, reports, notification groups, credentials, probe names, ticket subjects. NWD-DC01 and HLM-DC01 cannot be confused; two objects called DC01 can. The organizing side of this convention is covered in the multi-tenant guide linked above. The service side is that the code follows the client out of the platform and into every place you talk about them. That includes the credential vault, where a wrongly labeled secret is a leak waiting for a busy afternoon.
Shared surfaces that leak
In a shared platform, a few surfaces are global by nature, and they are where separation quietly fails. Each one needs a deliberate decision, not a default. A default is a decision somebody else made for a platform with one tenant.
- Global dashboards and overviews. The wall of every site is your most useful screen and the single most dangerous thing to show a client. It must be invisible to client roles, not merely "not linked."
- Maps. A network map that draws every client's sites is a leak by definition. Client-visible maps are built per tenant.
- Search. The search box is the classic escape hatch. A scoped dashboard with an unscoped search returns every client's devices to anyone who types a common hostname. Test it from a client login.
- Exports. A CSV of "all devices" or "all alerts" is a complete cross-client inventory. Exports run by client roles must be scoped; exports run by your staff should never be attached to a client-facing ticket without review.
- Alert and event history. A global event log visible to a client contact shows everyone's outages. Scope it, or hide it.
- Screens you share. Screenshots pasted into tickets and screen-sharing during client calls are the human leak. The habit is to open the client's scoped view before sharing the screen, never the internal wall.
- Integrations. A ticketing or chat integration that posts all alerts into one shared channel makes every client's incidents visible to whoever is in that channel. One channel per client, or an internal channel only.
- Probes. A probe inside a client's network holds that client's credentials and sees that client's traffic. One probe never serves two clients, however convenient a shared office building makes it. A probe polling across two networks is a device that belongs to both and can be trusted by neither.
Write it down: the contractual expectations
A promise that is not written down is a misunderstanding waiting for a bad day. The monitoring section of a service agreement, or a short data-handling appendix, should answer a handful of questions in plain language. It does not need legal poetry; it needs to be specific enough that both sides can check it.
Monitoring data handling — outline of what to write down
WHAT IS MONITORED the list of sites, device types, and services in scope,
and how additions are agreed
WHAT IS COLLECTED availability, performance metrics, configuration facts,
event logs (if any); nothing beyond this list
WHERE IT LIVES the platform's hosting location, and whether the
platform is shared with other clients
HOW LONG IT IS KEPT history retention in months; what is summarized vs raw
WHO CAN SEE IT the roles above, with named client contacts and the
statement that other clients cannot see it
NOTIFICATIONS who receives alerts and reports, and how changes are requested
ACCESS REVIEWS how often you review who has access, and that the client
may request the current list
INCIDENT DISCLOSURE that a misdirected message or other exposure is disclosed
to the client, and within what time
ON EXIT what is returned, in what format, what is deleted,
by when, and how deletion is confirmed
The appendix commits you to things you can actually do. Do not promise "military-grade isolation" or a retention period your database cannot deliver. Promise what the platform and your process genuinely provide, then provide it. Compare a provider who says "shared platform, logically separated, here is how we check" with one who says "totally secure" and cannot explain what that means. Clients are far more reassured by the first.
Proving separation to a client or an auditor
Sooner or later a client — or their auditor, or their cyber-insurance questionnaire — will ask you to demonstrate that the separation is real. "Trust us" is not evidence. Four things are.
Access reviews. On a schedule (quarterly is the usual rhythm), export the list of every account, its role, and the tenants it can see. Compare it against who should have access: current staff, current client contacts. Remove what should not be there, record what was removed, and keep the before-and-after. A stack of dated reviews is the single most persuasive document you can show.
Test accounts. Keep a viewer account for each client that belongs to you, not the client, and use it to see exactly what they see. Log in as it after every platform upgrade and after any change to roles, dashboards, or reports. Then hunt for anything that is not theirs — dashboards, maps, search, exports, event history. I once found the global map sitting in a client viewer account three upgrades after I had hidden it. The upgrade had helpfully restored the default, and nobody had logged in as the client since. Record the date and the result. A client who asks "how do you know?" can be shown a log of tests, or, better, offered a screen-share of the test being run.
Change records. When a device is added to a tenant, keep a record of who did it and when. Do the same when a role is granted or a report's recipients change. Your platform's audit log may cover this; if it does not, a simple change log does.
Incident records. The note from the tip above. An honest record of the one time it went wrong, and what changed afterward, is evidence of a working process, not of a broken one. Assembling all of this into something an auditor can consume without a tour of your platform is its own skill, covered in Compliance Evidence.
The separation checklist
Run this at onboarding, after every platform upgrade, and at each quarterly review. Upgrades are on the list because an upgrade is the most common way a hidden surface becomes visible again. Every row should have a name and a date next to it.
| Area | Check | How to verify |
|---|---|---|
| Membership | Every device belongs to exactly one tenant; nothing untagged | Filter for untagged or multi-tagged devices; expect zero |
| Roles | Every client login is scoped; every technician is scoped to assigned clients; admins are few and named | Access review export, compared against the staffing list |
| Dashboards | No global dashboard is reachable from a client role | Log in as the client test account; try direct links to internal views |
| Maps | Client-visible maps contain only that client's sites | Open every map from the test account |
| Search | Search from a client role returns only that client's objects | Search for a common name such as a generic server or switch name |
| Exports | Client-role exports are scoped; global exports are internal-only | Run each export type from the test account |
| Reports | Each scheduled report has one client's data and one client's list | Send to yourself first; check recipients quarterly |
| Notifications | Alert rules reference the client's contact group, never individuals; no cross-tenant recipients | Review recipients per rule; test-fire one alert per client |
| Integrations | Chat and ticket channels are per client or internal-only | List integrations and their destinations |
| Naming | All objects carry the client code | Search for objects without a code prefix |
| Contract | Data-handling appendix matches what the platform actually does | Read it against retention settings and role setup |
| Evidence | Access reviews, test logs, change records are current | Check the dates |
Offboarding a client cleanly
A client leaving is the ultimate separation test, because everything you built for them now has to come apart without leaving a trace on either side. The mechanical order — alerting off first, then logins and reports, then devices, then data — belongs to the multi-tenant guide. The service side has its own steps, and most of them happen outside the platform.
- Agree the exit in writing. The end date, what they receive, and the deletion date. Refer to the appendix you wrote; this is what it was for.
- Return their data in a usable form. A history export in a common format, their device inventory, their availability reports for the retention period. "Usable" means their next provider can read it without your platform.
- Remove yourself from their network. Your probe runs on their hardware or VM: uninstall it, or hand over the host. Your monitoring accounts exist in their directory: ask them to disable them, and confirm. Your SNMP community strings and API tokens are configured on their devices: ask them to change them. Their firewall has an outbound rule pointing at your platform: ask them to remove it. Each of these is a door you no longer have any business holding a key to.
- Revoke the client's access to you. Their viewer and contact logins, their report subscriptions, their chat or ticket channels.
- Delete on the date, and say so. Retain only what your own records genuinely require (invoices and the exit agreement, not their bandwidth graphs). Delete the rest on the agreed date. Send a short written confirmation of what was deleted and when. That letter closes the "for as long as agreed" clause, and it is the last thing they will remember about you.
- Retire their code. Do not reuse the client code for a new client. A stale reference in an old ticket or a forgotten rule should never point at someone new.
A client who leaves cleanly is a client who recommends you. A client who finds your probe still running six months later is a different kind of reference. So is one who receives a stray report from a platform they no longer pay for.
Where to go next
Separation is a promise with four clauses. Scoped roles, careful report and notification routing, and a naming rule that follows the client everywhere enforce it. So do deliberate decisions about the platform's shared surfaces, a written appendix, and evidence you can show. None of those is a large piece of work. Together they are the difference between a checkbox left in the wrong state on a busy Tuesday and a checkbox somebody checked on a quiet one. The rest of Monitoring Across Multiple Sites and Clients covers the architecture the tenants live in and the site rollups that feed each client's dashboard. It also covers the probe fleet running inside their networks and the reporting that proves the service. If your platform choice is still open, the licensing side of tenancy — what you pay for per client or per device — is in Licensing Models and Hidden Costs.
Put this into practice with SysPeep Monitor
The discipline in this guide is yours to apply whatever tool you run. SysPeep Monitor keeps every client's data in one central Windows service, collected by lightweight remote probes inside each site. Dashboards, maps, and reports are served from a single web console. That shape makes the checks above practical to run. The free trial lets you see how it organizes devices before you commit.
Download Free TrialLearn About SysPeep