Requirements Before Demos: Writing Down What You Actually Need
Somebody has decided it is time to "look at monitoring tools." Maybe the current one is limping. Maybe there is no current one and the network has been running on hope. The first move is usually to book a few demos, because it feels productive and fills the calendar. It is also the most reliable way I know to end up owning the wrong tool. A demo is built to make you want what you are being shown, and you have not yet decided what you want.
I have bought three monitoring tools and regretted one, and the regret came from doing things in the wrong order. This guide is the step that comes before the demos: writing down what you need. It is not the formal, signed-off document (there is a separate guide for that). It is a working list dug out of five places that already exist. Those are last year's incidents, the pains of whatever you run today, and the devices and protocols you genuinely own. The other two are the people who consume monitoring and the constraints nobody can wave away. By the end you will have that list sorted into must, should, and nice, and turned into test scenarios you can run. You will have it condensed onto one page you hand to every vendor before they show you a single screen.
In this guide
- The demo-first trap
- Where real requirements come from
- The requirements-gathering table
- Sorting into must, should, and nice
- Turning requirements into test scenarios
- The one-page summary you hand to every vendor
- Where to go next
The demo-first trap
A demo is a performance. The person giving it has done it hundreds of times, knows exactly which screens draw a gasp, and has a story ready for every awkward question. That is their job, and it means a demo teaches you the presenter's vocabulary, not your own needs. You walk out saying things like "we need topology-aware root cause" without having checked whether you ever had a problem it would have solved.
The damage compounds. Whichever tool you see first becomes the yardstick for every tool after it, a habit psychologists call anchoring. The second vendor is judged on whether they have the first vendor's map. The third is judged on both. By the fourth demo your "requirements" are simply the union of everything you have been shown. The thing you were originally trying to fix has quietly fallen off the list. For example, nobody knew the internet link had been down for forty minutes last month.
Demos are not the enemy. You will need them, and there is a whole guide in this pillar on steering a demo instead of being steered by it. The point is order. Write requirements first, and a demo becomes a test the tool can pass or fail. Watch demos first, and the requirements become a test you fail, because you no longer know what you needed.
Where real requirements come from
Real requirements are not invented in a meeting room with a whiteboard and a plate of biscuits. They are excavated from things that already happened and things you already own. Five sources produce nearly all of them.
Source 1: Last year's incidents
Open the ticket system, the outage emails, the post-incident notes if you have them, or just your memory of the days that went badly. For each significant outage or slow-burning problem, ask one question: what would have caught this earlier? The answers are your first and best requirements, because they are tied to pain the whole organisation remembers.
A file server that filled up on a Friday becomes "warn when any volume passes a threshold, with enough history to see it coming." A switch port that flapped for a week before anyone noticed becomes "poll interface status and error counters, and alert on a change." A certificate that expired on the customer portal becomes "check expiry dates and warn weeks ahead." An internet outage nobody detected becomes "test reachability of outside targets from inside the network." Ask a second, sneakier question too: what did we not know during the incident? If the answer was "which users were affected" or "what else was behind that switch," you have just discovered you need dependency mapping or a decent device inventory.
Source 2: The pains of the current tool
If you already run something, you have a list of grievances whether or not you have written it down. The alerts everybody ignores. The search that takes a minute to find a device. The upgrade that broke the collectors. The report management asked for that nobody could build. The devices it never discovered. Each is a requirement in disguise; flip it from a complaint into a positive, testable statement. "The alerts are useless" becomes "a noisy alert can be tuned in a few minutes without restarting anything."
There is a trap here, and it catches experienced admins more than beginners. When you are angry at the current tool, you write requirements only about its failures and forget everything it does well. Those are the things you have stopped noticing because they simply work. Those are requirements too, and the ones most likely to go missing from the replacement. So ask the opposite question as well: if the current tool vanished tonight, what would we miss at nine tomorrow morning? The answers (a particular graph, a daily summary email, a map the help desk keeps open) go on the list next to the grievances. I once lost a daily summary email this way, and learned who read it from the complaints.
Source 3: The devices and protocols you actually have
Now count things. How many switches, and from how many manufacturers? Routers, firewalls, wireless access points and their controller? Servers, split into Windows and Linux? Hypervisor hosts? Printers, UPS units, environmental sensors, the door controller somebody plugged into the network years ago? Cloud services and hosted applications the business depends on? Roughly how many network interfaces in total? A monitoring tool is only useful for the devices it can talk to, so this inventory is the heart of your coverage requirements.
Next, list the languages those devices speak. SNMP (Simple Network Management Protocol) is the standard way to ask a network device about its ports, traffic, CPU, and temperature. Almost every business-grade switch, firewall, printer, and UPS supports it. WMI (Windows Management Instrumentation) is the built-in way to ask a Windows machine about its disks, services, and memory. Flow records are summaries that routers and switches can export describing who talked to whom and how much. They are useful when the question is "what is eating the bandwidth?" Syslog is the plain-text event stream that firewalls and most network gear can send. Cloud services usually expose an API (a programmatic interface) or simply need to be tested from the outside for reachability and response time.
Be specific. "Supports SNMP" is not a requirement, because every tool on earth will say yes. "Polls stack member status and power-over-Ethernet budget on our switch family" is a requirement, and it separates tools quickly. Note the awkward devices too. These include the ancient controller that only speaks the oldest flavour of SNMP and the appliance that only reports over its own web interface. They include the building system on its own subnet. If a tool cannot reach them, you need to know now, not after purchase.
At Meridian Parts the monitoring tool was chosen from a demo run on the vendor's own lab, where every device answered on the first poll. The one device that mattered at Meridian was an elderly conveyor controller in the warehouse, speaking the oldest dialect of SNMP through a serial-to-Ethernet bridge. And it was on nobody's list because it had always just been there. The new tool could not discover it, could not poll it, and after a month of support tickets could not be persuaded to. The conveyor stopped on a Tuesday and the dashboard stayed green. The review recorded the controller as "out of scope", which it was, because nobody had written the scope down.
Source 4: The people who consume monitoring
Monitoring is not only for the person who configures it. The help desk needs a simple view that answers "is something down right now?" Then they can tell a user "yes, we know, it is the warehouse link" instead of rebooting a laptop for no reason. Management needs a page they can understand without a glossary, usually an uptime summary per site or service. The on-call person needs alerts that go to the right phone and carry enough context to act on. That means device, what failed, since when, and a link to the graph. The alerts must be able to be acknowledged so the rest of the team knows someone is on it. And you, the administrator, need the working view where devices get added, thresholds get tuned, and problems get diagnosed.
Spend ten minutes with one person from each group and ask a single question: what would you want to see, and when? Write each answer as a requirement. This is where the requirements a technical admin forgets come from: we design monitoring for ourselves, then wonder why nobody else uses it.
Source 5: Constraints
Constraints are the requirements no feature can override, and they are the easiest ones to lose sight of in a demo. A Windows-only shop with no Linux experience needs a tool that installs and runs on Windows, or is hosted so the operating system is somebody else's problem. A server room with no outbound internet access rules out anything that must phone home to a cloud console. A team of one needs something that can be installed, upgraded, and kept healthy in a few hours a month. That is because there is nobody to hand it to. Add the security policy (no agents on certain servers, no inbound connections from outside) and any data-residency rule. Add the database platform you already know how to back up and the virtualisation platform where the server will live. None of this comes up in a demo unless you raise it; a demo environment has no security policy and all the internet it wants.
If you are the whole IT department, the guide on setting up monitoring as a solo administrator is a useful companion, because its constraints are probably yours. Constraints are the true walk-away conditions. Write them at the top of the list, not the bottom.
The requirements-gathering table
The whole method fits in one table: a source, the question you ask it, an example requirement, and a starting priority. Yours will run to thirty or forty rows; the sorting step below trims it.
| Source | Question to ask | Example requirement | Priority |
|---|---|---|---|
| Incidents | What would have caught this earlier? | Warn when any server volume passes 85% full, with a trend graph | Must |
| Incidents | What did we not know during the outage? | Show which devices sit behind a failed switch instead of alerting on all of them | Should |
| Current tool (pains) | What do we swear at every week? | Tune a noisy alert in a few minutes without a restart | Must |
| Current tool (what works) | What would we miss tomorrow morning? | Keep twelve months of interface history for capacity questions | Should |
| Devices | Which device families do we own? | Poll stack members and PoE budget on our switch family via SNMP | Must |
| Devices | Which protocols do we need? | Receive syslog from the firewalls; accept flow records from the core switch | Should |
| Help desk | What tells you it is not the user's laptop? | A read-only status page listing current outages in plain words | Should |
| Management | What do you want to see each month? | Uptime report per site, exportable to a document | Nice |
| On-call | What do you need in an alert at 3 AM? | Alert names the device, what failed, since when, and links to the graph | Must |
| Constraints | What can we not do? | Installs on our own Windows server; no outbound connection required to function | Must |
| Constraints | Who will run it? | One person can install, upgrade, and maintain it in a few hours a month | Must |
Tip: write every requirement as something you could watch happen. "Easy to use" is a wish. "A junior technician can add a device and set a threshold after a one-hour introduction" is a requirement. That is because you can sit a junior technician in front of the tool and find out.
Sorting into must, should, and nice
Three buckets are enough. A must is a requirement you would walk away without. A should is strongly wanted and will weigh heavily when you score candidates. A nice is a tie-breaker. The buckets only work if you are ruthless about the first one. So test every candidate must with a single question: if a tool did everything else brilliantly but lacked this, would we reject it? If you hesitate for even a second, it is a should.
Expect somewhere between five and ten musts. If you have twenty-five, some of them are shoulds. Marking everything essential feels safer, but the cost arrives later. Either every tool fails your list and you start again, or you quietly demote musts during the evaluation to let a favourite through. At that moment the list stops being a tool for deciding and becomes decoration. Defend the musts. All of them. Especially the one the favourite happens to lack.
Shoulds are where the interesting differences between tools show up. They are what the weighted scoring sheet in the next guide is built to compare. Nices are genuinely fine to have. Just do not let a beautiful nice outvote a missing should, which is exactly what a good demo will tempt you to do. To check the list is scoped sensibly — not the whole world in phase one — the guide on monitoring goals and scope is the place to do it.
Turning requirements into test scenarios
A requirement is a sentence. A test scenario is what you do to prove a tool meets it. The difference matters because "supports dependency mapping" can be answered with a nod. But "when we unplug the core switch, we get one alert instead of forty" can only be answered by unplugging the core switch. Every must gets a scenario, most shoulds get one, and nices usually do not need one.
A scenario has four parts: the setup, the action, the expected result, and a space for the outcome. Keep them short enough to fit on an index card, because you will be reading them aloud during a proof of concept while somebody from the vendor watches. Two examples:
Scenario 4: Volume fills on the file server
Setup: file server monitored over WMI; volume warning at 85%
Action: copy files onto the volume until it passes 85%
Expect: warning within one polling cycle; alert names the volume;
graph shows the climb; nothing else fires
Result: [ ] pass [ ] fail Notes: ____________________
Scenario 9: Core switch goes dark
Setup: fifteen devices behind the core switch; dependency set
Action: disconnect the switch uplink during a maintenance window
Expect: one alert for the switch; the fifteen downstream devices
show as unreachable because of the parent, not as
fifteen separate alerts
Result: [ ] pass [ ] fail Notes: ____________________
The scenarios convert a feature claim into a pass or fail you can record. They make every vendor face the same test, which is the only way scores become comparable. They also double as the script for the proof of concept, so the work is not wasted. If your organisation wants the requirements as a formal document with sign-off, the guide on writing a monitoring requirements document covers structure and approvals. This page is about using the list to choose, which is a different job.
The one-page summary you hand to every vendor
Vendors tailor demos to whatever they know about you. If they know nothing, you get the standard show (the one with the map). If each vendor knows something different, you get incomparable demos. The fix is to give every one of them the same single page before the demo. Say plainly that you will ask to see the scenarios on it. The page turns the demo from a performance into a job interview, and good vendors are relieved by that, because it tells them what to prepare.
One page is a discipline, not a suggestion. It forces you to state the environment in a few lines and the constraints in three or four. You state the musts as a numbered list, the top shoulds, and what you expect from the demo. A workable template:
MONITORING TOOL REQUIREMENTS - SUMMARY FOR VENDORS Environment Sites: two (main office, warehouse), linked by VPN Network: 14 switches (two families), 2 firewalls, 22 access points Servers: 18 Windows, 6 Linux, on 3 hypervisor hosts Other: 4 UPS units, 9 printers, 6 cloud services we rely on Protocols: SNMP, WMI, syslog, flow records from the core, ping Team: one administrator plus a two-person help desk Constraints (non-negotiable) C1. Installs on a Windows server we own, inside our network C2. Operated part-time by one administrator C3. No agents on the finance servers Must-haves (we walk away without these) M1. Discovers and polls all device families above over SNMP/WMI M2. Alerts include device, failure, duration, and a link to the graph M3. A noisy alert can be tuned in minutes without a restart M4. Downstream devices are suppressed when their parent fails M5. Volume, certificate, and backup-job checks out of the box Should-haves (weighted heavily in scoring) S1. Read-only status page for the help desk S2. Twelve months of interface history S3. Syslog and flow collection from the firewalls and core What we will ask you to show Scenarios 1-9 (attached), on our own network, during a two-week proof of concept; we drive the console ourselves.
Two habits make the page more powerful. First, date nothing on it and put no vendor's vocabulary in it. Describe your needs in your words so every candidate has to translate, not just the ones who wrote the glossary. Second, keep a copy of exactly what you sent. Six months from now, when someone asks why a feature was not considered, the page is your answer: it was not a requirement, and here is the list everyone agreed to.
Where to go next
You now have something most buyers never build. You have a list of needs dug out of your own incidents, devices, colleagues, and constraints, sorted honestly and turned into tests. It is condensed onto one page every vendor sees before they say a word. The demos you book from here will feel different, because you will be asking the questions. I regret one of my three tools; I would like you to regret none. Next comes a weighted scoring sheet that survives the sales pitch. After that, the rest of How to Choose a Network Monitoring Tool covers cost, glitter, and the end-to-end playbook for a small team.
Put this into practice with SysPeep Monitor
When your one-page summary is ready, the fairest thing to do with it is to test candidates against it on your own network rather than trusting brochures. SysPeep Monitor is one option worth putting on that list. It is a Windows-hosted monitoring service that discovers devices automatically, collects over SNMP, WMI, and SSH, and can be tried for free. So you can run your own scenarios against it before you decide anything.
Download Free TrialLearn About SysPeep