Separating Clients and Departments: Multi-Tenant Basics
Three admins with the same problem walk into this article. The first works at an MSP (a managed service provider — a company that runs IT for other companies). The admin monitors twelve clients' networks from one system. Client A must never glimpse client B. The second runs monitoring for one organization whose departments each want their own view — and whose department heads absolutely will compare notes. The third inherited a group of subsidiaries under one corporate roof, each with its own gear and its own pride. Different org charts, identical problem: one monitoring system, many audiences, and each audience must see only its own world.
The name for the solution is multi-tenancy. A tenant is any audience with a boundary around it — a client, a department, a subsidiary. Multi-tenant monitoring is the craft of serving all of them from shared machinery without the boundaries leaking. Done well, it is mostly discipline: a tagging rule, some scoped views, routing that knows who owns what, and a quarterly audit. Done casually, it is a slow drip of awkward moments. A client sees a competitor's name in a report. A department receives another team's 3 AM alert. This guide covers the discipline: what tenancy actually separates, the primitives that implement it, and the operating habits that keep it clean for years.
In this guide
- What tenancy means in monitoring terms
- The organizing primitives: tags, groups, and names
- Visibility design: who sees what
- Alert routing: whose phone rings
- Configuration authority: who may change what
- Reporting without leaks
- Shared vs. dedicated infrastructure
- Operating multi-tenant: onboarding, offboarding, audits
- The tenancy checklist
What tenancy means in monitoring terms
"Separate the tenants" sounds like one requirement. It is actually four, and they fail independently. That is why each needs its own design decision.
- Visibility: who can see which devices, dashboards, and data. The MSP client logging into a status view must find their network and nothing else. The department head should not be able to browse the payroll servers out of curiosity.
- Alert routing: whose phone rings for whose gear. Alerts about a tenant's devices go to the people responsible for that tenant — and nobody else, at 3 AM or any other time.
- Configuration authority: who may change what. Even where tenants get some self-service, the boundary decides whose thresholds, checks, and contacts a given person can edit.
- Reporting boundaries: per-tenant numbers that stand alone. Each tenant gets their availability, their trends — with no accidental glimpse of how the neighbors are doing.
Notice what tenancy is not: it is not necessarily separate systems. The whole economy of the multi-tenant approach is that one set of machinery serves everyone: one poller fleet, one database, one alert engine. Each audience experiences a scoped view of it, as if it were theirs alone. Think of an office building: one foundation, one plumbing system, one electrical feed — and locked doors that make each floor feel private. Your job is the locks.
The organizing primitives: tags, groups, and names
Every tenancy feature in every tool — scoped dashboards, filtered alerts, per-client reports — ultimately asks the same question: which tenant does this device belong to? So the foundation of multi-tenancy is embarrassingly simple. Every device is assigned to exactly one tenant, using whatever grouping primitive your tool offers — groups, sites, tags, custom fields. One tenant, no exceptions, no "we'll sort it later." Every view, every routing rule, and every report you build afterward silently trusts this assignment. A device tagged to the wrong tenant is a leak already in progress, just waiting for a report cycle to expose it.
Two supporting habits make the rule enforceable. First, naming that carries the tenant code: pick a short code per tenant (ACME, FIN, WHSUB). Lead device names with it — ACME-FW01, FIN-SQL02 — exactly the way site codes work in multi-site monitoring. The convention comes from From One Site to Many. If your tenants are also sites, one code can serve both. Names travel everywhere — alerts, logs, tickets, screenshots. A name that announces its tenant makes mis-filing visible to the naked eye.
Second, the untagged-device alarm — tenancy's intake rule. New devices arrive constantly: discovery finds them, colleagues add them in a hurry. Create a standing check or saved view for "devices with no tenant assignment." Treat anything in it as an alarm condition to clear within a day. An empty quarantine is the health check of the whole scheme. The alternative is an unassigned pile that grows quietly until nobody remembers what half of it is.
Tip: "exactly one tenant" seems to break on shared infrastructure — the core switch every department rides, the MSP's own firewall in front of three clients. The clean answer: shared gear belongs to its own tenant, usually called CORE or SHARED, owned by you. It gets your routing and stays out of tenant views. The "exactly one" rule survives intact. That matters, because every exception you allow becomes a place where the other three separations can silently fail.
Visibility design: who sees what
With devices cleanly assigned, visibility is a matter of building each audience the view it deserves. Where your tool supports user roles and permissions, back the view with a login that cannot wander outside it. A dashboard someone politely avoids is a courtesy; a scope their account enforces is a boundary. Prefer boundaries.
The MSP staple is the read-only client view. What belongs in it: the client's services and their current status, plus availability over a recent window. Add the handful of graphs they actually care about (their internet link, their key server). What does not: your other clients' existence in any form, your internal alert noise, your infrastructure, and your operational notes. A client view is a clean storefront, not a tour of the kitchen.
Concretely, a good client view fits on one screen and reads in the client's own words. A status row per contracted service: "Internet link — up, 14 ms." "Office server — up, disk 61% used." "Wi-Fi — 3 of 3 access points up." Below that, this month's availability figure and a short list of recent incidents with durations. That is the entire view — every question they would phone about, answered. Not one pixel requires explaining your other clients or your own plumbing. Run this test whenever you change anything: log in as the client role and hunt for anything that is not theirs. Device pickers, search results, report menus, and map views are the classic escape hatches that quietly ignore scoping.
The department variant is the same pattern with a different payoff: a self-serve status view per department. Its value is measured in tickets that never get opened — "is it down?" answered by a glance instead of a call. It also builds trust: a department that can see its own world stops suspecting that IT hides things. Above all the scoped views sits the admin view: you and your team see everything, across all tenants. Someone has to operate the whole building. Keep admin accounts few, named, and protected — each one is a key to every floor.
Alert routing: whose phone rings
Routing is tenancy's second separation, and it is where mistakes wake people up. The mechanics are a tenant-to-contact mapping. Give each tenant a contact group: the MSP techs assigned to that client, the department's own on-call, or the subsidiary's IT person. Give each tenant a schedule, too. Tenants keep different hours, honor different maintenance windows, and have different opinions about being paged overnight. Build alert rules on the tenant assignment itself — "devices tagged ACME notify group ACME-ops". A correctly tagged device is then automatically correctly routed. The tagging discipline pays its second dividend.
Then comes the question that makes multi-tenant routing genuinely interesting: when the shared core fails, who gets told? The switch that carries four departments dies; the MSP's upstream link serving three clients drops. The honest answer is: everyone affected, each in their own terms. Affected tenants get a message scoped to their world — "your monitored services are currently impacted; we are working on it". They do not get a description of your core device. That would be your internals leaking (and, for an MSP, an architecture disclosure). You and your team get the real alert, with the device name and the gory details. You are the ones fixing it.
Keep that fan-out honest with dependency awareness: tenants whose services ride the failed component get notified; tenants who do not, do not. A shared-core failure that pages all twelve clients when it touches three teaches nine of them to ignore you. Cried-wolf tenants are the multi-tenant version of alert fatigue. If your dependency mapping cannot yet say who rides what, that mapping is the prerequisite to build first.
And exercise the paths. A tenant's routing that has never carried a test alert is a guess wearing a checkmark. Once a quarter, push a test down each tenant's path and confirm it reached the right people — and only them. The audit table at the end of this guide asks for exactly this. Wrong routing discovered by drill costs a minute, while wrong routing discovered by outage costs an apology.
Configuration authority: who may change what
The third separation tends to get skipped, because visibility and routing feel like the whole job. Then a helpful department admin "tunes" a threshold and quietly mutes an alert you were depending on. Configuration authority is the boundary around changing things, and the safe baseline is simple: tenants observe, you operate. Read-only is the right default for every tenant-facing login, and most tenants genuinely prefer it — they wanted a window, not a control panel.
A tenant may legitimately want self-service. A department may maintain its own contact list, or a sophisticated client may tune their own disk-space warning levels. In that case, delegate a narrow, explicit slice. Ask the blast-radius question of every role you grant: what is the worst this login could change, and whose world could it touch? The answer must never include another tenant. Everything not delegated flows through you as a request. That small friction is what keeps one coherent, supportable system. Writing it into the service agreement sets the expectation before anyone tests it. Finally, keep whatever change history your tool offers switched on, and insist on named accounts. The quarterly audit will ask "who changed what," and a shared admin login answers that question with a shrug.
Reporting is where tenancy earns money and where it leaks most easily. The deliverables themselves are straightforward once devices are cleanly assigned. For MSPs, there is the per-client monthly: availability of their services, incidents and durations, and capacity notes. It is generated per tenant on a schedule. Often, it is the single artifact that justifies the invoice. For internal teams, the department scorecard — the same numbers in the same shape, feeding budget conversations and honest expectations. Write both in tenant terms — services first, devices second, jargon last. The reader of a monthly is a manager, not an admin. Scope every scheduled report to one tenant's assignment, and the generation takes care of itself.
The leaks happen around the edges, so run the leak checklist on three surfaces. Reports: the ranked all-tenants availability table is a wonderful internal tool and a catastrophic thing to mail outward. Comparative data is for the admin view only, and every outbound report should contain exactly one tenant's world. Dashboards: mind the physical layer. The wall-mounted screen in the office cycling through all clients is a leak with a mounting bracket the moment a client visits. Anything on public display gets the same scoping as a client login. Alert content: grouped or digest notifications that bundle several tenants' events into one message will eventually mail tenant A a line about tenant B. Check that notification templates and groupings respect the boundary. The alert engine does not know your contracts.
Shared vs. dedicated infrastructure
Everything so far assumes the economical default: one monitoring system, scoped views. When does a tenant earn dedicated machinery? There are two rungs, and it pays to climb them for reasons rather than reflex.
A dedicated probe is the routine rung — and for an MSP it is simply the standard pattern. The client's network is a remote site, so a probe sits inside it. It polls locally, holds only that client's credentials, and reports home. That is the multi-site architecture wearing a tenancy hat, with the same blast-radius logic. A compromised probe at one client exposes one client. Deployment mechanics live in Deploying Remote Probes That Behave. A department with its own building or an isolated network segment earns a probe by the same reasoning.
A dedicated instance — a wholly separate monitoring system for one tenant — is the expensive rung. The honest triggers are specific. A contract or regulation may demand that their data live apart from anyone else's. A tenant may be so large it would dominate the shared system's capacity (the load math from When Monitoring Gets Slow applies). Or a tenant may need configuration authority so deep that sharing an instance means sharing administration. Absent one of those, a separate instance mostly buys you a second system to patch, upgrade, and remember. Multiply that by every tenant who gets one. The default remains: shared machinery, scoped views, dedicated probes where networks or contracts call for them.
Operating multi-tenant: onboarding, offboarding, audits
Multi-tenancy stays clean the same way multi-site does: by turning the recurring work into kits. The tenant onboarding kit mirrors site onboarding step for step (the template idea comes from From One Site to Many). Assign the tenant code. Create the group and contact group. Deploy the probe if the tenant's network calls for one. Discover and tag every device — clearing the untagged quarantine before you call it done. Build the scoped view and login. Wire routing and schedules, then schedule the report. Record the tenant sheet — contacts, escalation, report recipients, anything contractual about data. Run the visibility test as the final step: log in as the tenant and hunt for anything that is not theirs. The first tenant takes a day and produces the kit; by tenant four it is an afternoon. That is the same compounding that makes site onboarding routine.
The offboarding mirror matters just as much, especially for MSPs, and has an order. Disable the tenant's alerting first. A departed client's 2 AM alert going to a tech who no longer serves them is embarrassing at best. Revoke their logins and report schedules, then remove or archive their devices. Handle their data deliberately. Export history if the contract promises it, retain what your records require, and delete the rest on purpose rather than by neglect. A tenant that leaves should leave completely; half-removed tenants are where stale credentials and phantom alerts live.
Between arrivals and departures, audit quarterly. The centerpiece is the wrong-tenant device hunt. Empty the untagged quarantine, then skim each tenant's device list for names whose prefix disagrees with their group. The naming convention makes that thirty seconds of scanning possible. Re-run the leak checklist on reports, dashboards, and alert templates; review who holds admin access; and confirm each tenant's contacts still work there. Fifteen quiet minutes per quarter, against the alternative of discovering a mis-tagged device via an apology call.
The tenancy checklist
| Separation | Mechanism | Quarterly audit question |
|---|---|---|
| Visibility | Tenant-scoped views and logins; admin view apart | Log in as each tenant role: can you find anything that is not theirs? |
| Alert routing | Tenant contact groups, schedules, dependency-aware fan-out | Did any alert reach the wrong audience — and has each tenant's path had a test alert? |
| Configuration authority | Role permissions; few, named admin accounts | Who changed what, and were any changes outside their tenant? |
| Reporting | Per-tenant scoped reports; comparative data internal-only | Does any outbound report, dashboard, or screen show more than one tenant? |
| Intake | One-tenant-per-device rule; untagged-device alarm | How many devices sit untagged or with a name/group mismatch right now? |
Where to go next
Multi-tenancy is the last of the four scaling pressures this pillar covers. It composes with the other three: tenants often arrive as sites (From One Site to Many). They get their own probes (Deploying Remote Probes That Behave), and add real load (When Monitoring Gets Slow). They raise the stakes on the monitor's own uptime (High Availability for Monitoring). When twelve tenants trust one system, that system had better be trustworthy. The whole scaling story is collected at Scaling & Distributing Monitoring.
Put this into practice with SysPeep Monitor
Clean tenancy runs on shared machinery worth trusting. SysPeep Monitor provides it. Auto-discovery brings each new network in quickly. Remote probes can be stationed inside client or department sites. Alert rules and dependencies route noise-free notifications. Dashboards, maps, and reports come from a single web console. The free trial at /download/ lets you rehearse the whole onboarding kit on one tenant first.
Download Free TrialLearn About SysPeep