Home › Topics › Digital Experience Monitoring: From Device Health to User Happiness › DEM on a Budget

Digital Experience Monitoring on a Small-Team Budget


Everything written about digital experience monitoring seems to assume a team, a budget line, and a product with an agent on every machine. You have two people and a monitoring server that already does a decent job on switches and servers. You also have a manager who would like to know why the sales team keeps saying "it's slow" without spending anything to find out. I have done DEM from exactly that position. The useful parts are mostly habits and small scripts, and the expensive parts are only worth buying once the habits exist.


This guide is a ladder. Each rung is something a small team can build in days rather than months. Each one produces data you will actually read. And each one makes the next rung easier. You climb as far as your situation demands and stop where the return runs out. Plenty of small shops live happily on the first three rungs forever, and nobody has ever made a slide about them.


By the end you will know what each rung costs in effort and gives back. You will have a plan for the first month. You will be able to recognize — honestly, without a vendor telling you — the signs that you have outgrown the do-it-yourself rungs. Those are the signs that a dedicated tool would earn its keep.


In this guide

  • Why a ladder, and why in this order
  • Rung 1: Synthetic checks from user locations
  • Rung 2: A handful of reference endpoints
  • Rung 3: Mining the help desk
  • Rung 4: Endpoint telemetry at scale
  • Rung 5: A dedicated tool, when it earns its keep
  • The ladder at a glance
  • A starter plan for the first month
  • Honest signs you have outgrown DIY

Why a ladder, and why in this order


The order is not arbitrary. Each rung is cheap because it borrows something from the rung below it. Synthetic checks give you a trend line to compare reference endpoints against. Reference endpoints teach you which metrics matter before you collect them from everyone. Ticket mining tells you which sites and applications deserve the endpoints. And by the time a dedicated tool is on the table, you know exactly which journeys, personas, and sites it must cover. That is the difference between a tool that gets used and one that becomes a very expensive screensaver.


There is also a rung zero, which this guide assumes you already have: ordinary infrastructure monitoring of your switches, servers, links, and core services. DEM is measured from the user's seat, but every finding it produces has to be checked against what the infrastructure was doing at that moment. Without that timeline, experience data is a list of symptoms with nothing to compare them to. If you do not have rung zero, build it first; it is cheaper and it catches more.


Rung 1: Synthetic checks from user locations


A synthetic check is a robot user: a scheduled test that performs a fixed action and records how long it took and whether it worked. You almost certainly run some already, from the monitoring server. The rung-one twist is to run them from where the users are. Put a small, boring machine in each office, on the same network segment as the people. That could be a spare desktop, an old laptop, or a tiny single-board computer. Have it time the three or four journeys that matter most. Resolve a name, open the login page of the main application, fetch a small file from the shared drive, reach the video-meeting service. Log one line per check per interval and ship the log somewhere central.


What it gives back is enormous for the effort. You get a trend line per site that does not depend on anyone complaining. You catch a slow morning before the first person arrives. And you can answer "is it the branch or is it everyone?" in one glance by comparing the same check from two sites. The design details — which targets, what interval, how to keep the probe from becoming the problem — are covered in the guide to designing synthetic probes.


What it misses is equally clear. A synthetic check sees the path and the application, but nothing about anyone's actual laptop. It sees nothing about Wi-Fi at the far end of the floor, because the probe is wired to a switch and never moves. It is one fixed action from one fixed device. The probe has never had a bad day, which is exactly its limitation. That is precisely why rung two exists.


Cost: roughly a day per site to build and a few minutes a week to glance at. Ongoing: nearly nothing.


Rung 2: A handful of reference endpoints


A reference endpoint is a real user's real machine that has agreed to report its health. Two or three per site, or per persona if your personas are very different (a warehouse scanner and a designer's workstation do not stand in for each other). Pick volunteers who are chatty, because the whole point is to match their numbers to their complaints. Pick machines that are typical rather than the newest or the oldest.


On each one, a scheduled script gathers the endpoint-side numbers every five minutes. These are CPU, memory, disk activity, Wi-Fi signal, gateway round-trip, DNS lookup time, and a timed request to the main application. The script writes one summary row to the same central place as the synthetic logs. The exact metrics and the privacy rules that go with them are the subject of the endpoint-side metrics guide. The short version is collect health, not content, and write one plain page saying what you collect and why before the first script runs. Before. Not during the pilot. Not "once we see what it collects".


This rung is where DEM starts to feel like DEM. For the first time you can see the device layer and the last few metres of Wi-Fi. You can lay a volunteer's "it was slow at ten" next to their own laptop's disk activity at ten. It is also where you learn which metrics actually move when people complain, which is knowledge you will need before collecting from everyone.


Cost: a few days to write and test the script, an hour per machine to deploy and explain. Ongoing: an occasional script fix, and the discipline to look at the rows when a volunteer complains.


Rung 3: Mining the help desk


Your ticket system is an experience-monitoring dataset that has been collecting for years, and almost nobody reads it as one. (It has been collecting opinions too, which graph less well.) The prerequisite is structure. Every slowness ticket needs a time, a place, an application, and a device recorded in fields rather than buried in free text. Once that is true, a monthly export into a spreadsheet turns complaints into a map.


Three views do most of the work. A count of tickets by application tells you which journeys to measure first. A grid of hour of day against location shows you when and where pain clusters. It is remarkable how often the answer is "the branch, between two and four," which is a link. Or it is "everywhere, first thing Monday," which is updates. And a count by device age or model reveals when the real problem is a fleet of tired laptops. That is a purchasing conversation rather than a network one.


LocationMorningMiddayAfternoonTop application
Head office, floor 1312CRM
Head office, floor 2 north269Video meetings
Branch office1214Shared drive
Remote workers543VPN login

A month of tickets summarized like that is a work plan. The branch afternoon cluster wants a look at the link; the north end of floor two wants a look at the access point. The remote workers want a look at the VPN gateway's morning load. None of it required a single new sensor. Its blind spot is the silent sufferer — the person who stopped reporting things a year ago. That is why you still need rungs one and two, and why you should occasionally ask people directly.


Cost: an afternoon to add the fields and build the spreadsheet. Ongoing: an hour a month, and a short conversation with the help desk about filling the fields in properly.


Tip: when you add the four fields to the ticket form, tell the help desk why, and show them the first month's map. People fill in fields they have seen turned into a fix; they stop filling in fields that vanish into a database.


Rung 4: Endpoint telemetry at scale


At some point the reference endpoints are not enough. The complaint comes from a machine you do not instrument. Or your manager asks how many users had a bad week and you can only answer for six of them. Rung four is the rung-two script, or a lightweight agent, on every machine, reporting into a real collector with a real database.


This is a project rather than a task. The script needs a deployment mechanism, a way to update itself, and a way to be turned off. The collector needs to handle every machine waking up at nine and needs somebody to keep it running. The database grows — a summary row every five minutes from a few hundred machines is modest, but it is now a service you own. And the privacy page, which was a courtesy at rung two, is now a policy. That means management sign-off, employee representatives where they exist, and a retention schedule you actually enforce. The afternoon script from rung two is now a product, and you are its vendor.


What you get back is the thing the earlier rungs cannot provide: distributions. With every machine reporting, you can compute a per-persona experience score. Far more importantly, you can see its bottom tenth — the users having the worst days, by name and location, before they file anything. That capability is what turns DEM from a troubleshooting aid into a management tool, and it is the honest reason to climb this far. The experience scores guide covers how to build the score once the data exists.


Cost: weeks of effort, spread over a couple of months, plus an ongoing slice of one person's time. Ongoing: real. This is the rung where the maintenance of the monitoring starts competing with the monitoring itself.


Rung 5: A dedicated tool, when it earns its keep


A dedicated DEM product packages rung four so you do not have to build it. You get an agent for every operating system you run and a collector that scales. You get a console that lines up device, network, path, and application on one timeline, plus ready-made scoring. Usually you get some ability to trace the path from a laptop to a cloud or SaaS service hop by hop. SaaS is software as a service: an application somebody else hosts and your users reach through a browser. The product costs money, typically per endpoint, and it costs the time to roll it out and learn it. Whether it earns that back depends on four questions, none of which a vendor can answer for you.


  • Headcount. Below a few hundred endpoints, a script and a small database are usually cheaper than a product, in money and in time. Above that, the script's deployment and maintenance burden starts to eat the time it was saving. At that point, a supported agent becomes the cheaper option even at a per-seat price.
  • SaaS-heavy. If most of your users' journeys end at services you do not host, you cannot instrument the server side. The client's view is the only view you will ever have. And a tool built around it — especially one that can trace the path to each provider — is doing something your scripts do badly.
  • Remote-heavy. Home networks are invisible to everything except an agent on the laptop. When remote workers are a large fraction of your users, fleet-scale endpoint collection is not a nice-to-have. Building your own collector for machines that are never on your network is harder than it looks.
  • Executive pressure. If someone above you wants an experience score on a slide every month, that is both a reason to buy (they will fund it) and a warning. In that case, make sure the journeys and personas are defined before the tool arrives, or the slide will show a number nobody can explain.

At Ashgrove Housing the tool came first. An agent went onto every laptop before anyone had written down a journey. For a quarter the console showed the northern branch in red with the cause "network". Nobody could turn that into a switch, a link, or a change. The administrator who had argued for a ladder borrowed a spare laptop and put it on the branch's user network. They had it time the housing system's login page every five minutes. Within a week the graph showed nine seconds at the branch every afternoon and one second at head office. The difference turned out to be a change the previous month. That change sent the branch's web traffic through head office and back out again. The laptop had cost nothing and answered in seven days a question the console had been not answering for three months. Both are still running, and the laptop is the one people look at first.


Be equally clear about what a tool does not fix. It will not define your journeys or personas. It will not replace infrastructure monitoring, because it sees symptoms from the seat and not causes in the rack. It will not build your feedback loops with users. And it will not fill in the four fields on a ticket. Everything from rungs one to three is still yours to do. A shop that skips them and buys rung five usually ends up with a beautiful console that confirms users are unhappy and cannot say why.


The ladder at a glance


RungEffort to startOngoingGives backBlind spot
1. Synthetic from user sitesA day per siteMinutes a weekTrend per site; early warning; site-versus-site comparisonReal devices, Wi-Fi, real usage
2. Reference endpointsA few days, then an hour per machineOccasional script fixesDevice and local-network view; which metrics matterEveryone who is not a volunteer
3. Help-desk miningAn afternoonAn hour a monthWhere and when pain clusters; the human layerSilent sufferers
4. Telemetry at scaleWeeks, over a couple of monthsA real slice of one personDistributions; the worst tenth by name; per-persona scoresCauses in the rack (still needs rung zero)
5. Dedicated toolBudget, rollout, learningLicence and administrationRung four without building it; SaaS path tracing; fleet-scale agentsUndefined journeys; missing infrastructure monitoring; no feedback loops

A starter plan for the first month


Four weeks is enough to stand on the first three rungs. The plan below is deliberately modest so that it survives contact with a normal month of interruptions.


  • Week 1: decide and prepare. Write down the three journeys that generate the most complaints, in user language. Add time, place, application, and device fields to the slowness ticket template and tell the help desk why. Confirm that your monitoring server, the machine that will run synthetic checks, and your ticket system all synchronize their clocks to the same source. Correlation is impossible without it.
  • Week 2: rung one at the main site. Put a small machine on the main office's user network and have it time the three journeys every five minutes, logging one line per check. By the end of the week you have your first trend line. If you have a branch, repeat there.
  • Week 3: rung two, with volunteers. Write the endpoint script and test it on your own machine for a couple of days. Then write the one-page transparency note and deploy to two or three volunteers per site. Put their rows in the same place as the synthetic logs.
  • Week 4: the first review. Export the month's slowness tickets and build the hour-by-location grid. Take the three worst tickets and walk each one through the layers against your new data. Name which square of the reported-versus-measured matrix it lands in; the guide to closing the “it feels slow” gap is the procedure. Decide, based on what you found, whether the next month adds sites, adds volunteers, or simply keeps looking.

At the end of the month you will not have a score, and you should not pretend to. You will have three trend lines, six machines telling you how they feel, a map of where complaints cluster, and three complaints you can explain. That is more experience monitoring than most organizations of any size actually do.


Honest signs you have outgrown DIY


The do-it-yourself rungs stop being cheap at a point that is easy to miss from the inside, because each extra bit of maintenance feels small. These are the signs that you have passed it. The one I missed longest was the monthly spreadsheet safari, which I had started to enjoy.


  • Deploying a script change is a project. When updating the endpoint script across the fleet takes a week of chasing machines, you are paying agent money in hours.
  • You cannot answer "how many users are in the red" without an afternoon. If the question is being asked regularly and the answer requires an afternoon in a spreadsheet, the collector and reporting are the bottleneck.
  • The volunteers stopped being representative. Six chatty people in two offices cannot stand in for a workforce that is half remote, and you know it.
  • Most journeys end in someone else's cloud. If your synthetic checks and your endpoint rows both point at "the provider" more often than not, path tracing to those providers is the thing you are missing. In that case, building it yourself is a poor use of a small team.
  • Someone wants the score on a slide every month. A recurring executive audience is a budget. And a budget spent on a supported tool is usually better than the same budget spent on your evenings.
  • You maintain the collector more than you read it. The moment monitoring the monitoring takes more time than acting on it, the DIY rung has stopped paying.

The signs that you have not outgrown it are just as important, because a tool bought too early solves nothing. Here are those signs. You do not yet have solid infrastructure monitoring. You have not written down the journeys. The ticket fields are still empty half the time. And nobody has ever walked a complaint through the layers against real data. Fix those first. They are free, and every one of them makes a future tool more useful on the day it arrives.


Where to go next


The ladder is the plan. Start with synthetic checks from where users sit, a few honest endpoints, a ticket queue read as data. Only then come the scale and the tools. Each rung pays for the next, and you may never need the top one. Two people and a spare laptop can be standing on the first three by the end of the month, with no budget line and nothing to explain on a slide. The background covers what DEM is, which layers make up an experience, and what it adds to the monitoring you have. You can find it in Digital Experience Monitoring in Plain Language. The full series lives under Digital Experience Monitoring: From Device Health to User Happiness.


Put this into practice with SysPeep Monitor

Rung zero of this ladder is infrastructure monitoring you can trust, and it should not be the expensive part. SysPeep Monitor discovers your devices, collects their health over SNMP, WMI, and SSH, and puts the graphs and alerts in one web console. It includes lightweight remote probes for the branch offices where your synthetic checks and reference endpoints will live. The free trial installs on any Windows machine.

Download Free TrialLearn About SysPeep