Home › Topics › Baselining & Knowing Normal › Collecting Baselines

Collecting Your First Baselines: A Practical Method


Knowing what a baseline is and owning one are different things. In the same way, knowing what a passport is does not get you through the airport. If the concept is still fuzzy, start with what a baseline really is and come back; this guide is the practical half. It takes you from "we have no documented normal for anything" to a written set of baselines for the metrics that matter, in about a month. And most of that month is your monitoring system doing the work while you do your actual job.


The method has five steps. Choose a short list of metrics. Let the monitoring gather quietly. Read what it gathered. Write the results into a baseline register. And sanity-check your numbers against published healthy ranges. None of the steps is hard. The whole project mostly fails for one reason only: nobody ever starts it, because "baseline the network" sounds like a research program. It is not. It is a dozen metrics, two graphs each, and a one-page table at the end.


By the end of this guide you will have a project plan you can start this week and a template for the register. If you have no monitoring tool at all yet, you will also have a scrappy script-based fallback that beats having nothing.


In this guide

  • Step 1: Choose what to baseline (the starter dozen)
  • Step 2: Let the monitoring gather
  • Step 3: Read what you gathered
  • Step 4: Write the baseline register
  • Step 5: Sanity-check against reference ranges
  • No tool yet? The lightweight alternative
  • The one-month project plan
  • Where to go next

Step 1: Choose what to baseline (the starter dozen)


Do not baseline everything. A modern monitoring tool can record thousands of metrics, and every one of them technically has a normal. But a register with four hundred rows is a register nobody reads, updates, or trusts. The selection rule is simple: baseline the key metrics of your most important services, plus the shared infrastructure everything rides on. If you have already thought about which systems deserve monitoring attention at all, this is the same list. The monitoring scope pillar covers how to draw that line. If you have not, the shortcut is one question: "which things, when they get slow or full, make the whole company feel it?"


For a typical small or mid-size network, that produces a starter dozen that looks like this:


#MetricWhereWhy it earns a slot
1Internet/WAN utilization (both directions)Edge router or firewall WAN portThe shared pipe everyone feels; the classic slow-creep metric
2Latency and packet loss to anchor targetsFrom the monitoring host to your ISP gateway and a stable outside addressYour evidence in every "the internet is slow" conversation
3Core switch CPUCore/distribution switchRises quietly before loops, floods, and misconfigurations get loud
4Core uplink utilizationBusiest inter-switch or server-facing linksThe internal pipes that congest first
5CPU per key serverEach Tier-1 server (domain controller, file, mail, main app, database)"Is 74% bad?" needs an answer per server, not in general
6Memory per key serverSame serversMemory normals differ wildly by role; databases should look "full"
7Disk free space and growth rateSame servers, data volumesGrowth-per-week is the number that predicts outages
8DNS response timeEach internal DNS serverEvery app depends on it; slow DNS masquerades as "everything is slow"
9Latency to key cloud servicesFrom inside the network to the apps people live inSeparates "our link" from "their outage" in seconds
10Wi-Fi client count per access pointEach AP or the controllerClient-count jumps reveal dead neighbor APs and crowd events
11Backup job durationBackup serverA backup window that grows 5% weekly will eventually collide with the workday
12Firewall CPU and session countEdge firewallEarly warning for both traffic growth and misbehaving devices

Adjust freely — a school cares about different things than a law firm — but keep the count near a dozen. You can always run a second round later for the next tier; baselining is a habit, not a one-time census.


Just as deliberately, leave things out. Skip per-user bandwidth, individual access ports, test machines, and printers (a printer's only stable normal is disappointment). Anything you would not act on if its behavior changed is not worth a register row yet. A short list you actually finish beats a comprehensive list you abandon in week two.


Step 2: Let the monitoring gather


Now the easy part that everyone gets wrong: wait. Confirm your monitoring tool is polling each chosen metric. Confirm the data is actually landing: check on day one and day two. Discovering a broken collector on day fourteen is a special kind of sadness. Then let it run untouched.


How long is long enough?

The rule: capture at least two full business cycles of whatever rhythm your organization runs on. For most shops the dominant rhythm is weekly — Monday looks like Monday, Saturday looks like Saturday — so the minimum is two full weeks. Why two and not one? Because one of anything might be a fluke. One Monday could be a holiday, a snow day, or the day the ERP system fell over. Two Mondays that agree are the beginning of a pattern. Your organization may have a strong monthly pulse — payroll runs, month-end reporting, billing cycles. If so, you want a full month so the crunch days are in the data, not a surprise later. (Annual rhythms like enrollment season or retail peaks get folded in over time; weekly rhythms and seasonal patterns covers reading all of these.)


Resist reading conclusions early

Around day three the graphs start looking interesting and you will be tempted to declare normals. Don't. Three days of data answers "what did Tuesday look like?" and nothing else. Early conclusions have a way of getting written down, repeated, and never corrected. Peek at the graphs to verify collection is healthy, but save the judgments for the end of the window.


Mind the polling interval

One technical trap: a baseline can only be as honest as the samples underneath it. If a metric is polled every half hour, or stored as one-hour averages, short peaks vanish into the arithmetic. With those samples, a link that slams to 95% for ten minutes every morning can average out to a serene-looking 40%. In that case, your "normal" will be a comfortable fiction. Five-minute polling is a sensible default for utilization and latency on the starter dozen. One-minute is nice for the WAN link if your tool and devices are comfortable with it. The general problem of averages hiding truth is worth ten minutes of your time. See how network metrics get misread before you trust any smooth-looking graph.


Step 3: Read what you gathered


Two weeks later you have data. Now comes the genuinely enjoyable part: reading each metric's story. For every metric on your list, look for four features, in this order:


  • The day-shape: what does a typical working day's curve look like — when does it climb, plateau, dip, fade?
  • The week-shape: which days differ? Is Monday heavier? Does Friday fade early? What do weekends do?
  • The peaks: how high do regular peaks go, and — just as important — when do they happen and do they repeat?
  • The floor: what does the metric do when the building is empty? The quiet floor is your reference for "nothing is happening," and changes to it are eerily good early warnings.

A worked example: reading a fortnight of WAN utilization

Here is a fortnight's graph of an office WAN link, narrated the way you should narrate yours. Overnight, the line rests on a floor around 3% — keepalives, updates, the murmur of idle machines. The exception is a block between 01:00 and 03:00 where it jumps to 60%. That is offsite backup replication, and its regular shape makes it instantly recognizable. At about 07:40 the line stirs as early arrivals land. Then a sharp spike runs from 08:50 to 09:10 touching 65%. That is the login surge, everyone's mail clients and cloud folders syncing at once. The day then settles into a working plateau wandering between 35% and 50%. There is a dip toward 25% at lunch and a second, softer bump around 14:00. From 16:30 it fades, reaching the floor by 19:00. Friday's fade starts two hours earlier (draw your own conclusions). Saturday and Sunday sit on the floor — except a 20% blip on Sunday at 02:00, which turns out to be the patch cycle. And crucially, week two repeats week one within a few percent everywhere. That agreement is what lets you call these numbers normal rather than recent.


When the two weeks disagree

Sometimes week two refuses to echo week one — Tuesday's peak is double, or the floor moved. Before averaging the disagreement away, find out why. Usually one week contains an explainable oddity: a holiday, an all-hands meeting, a big file migration, a marketing campaign launch. If you can name the cause, baseline on the ordinary week and note the exception. "All-staff video events push the WAN peak to 80%" is useful knowledge in its own right. If you cannot name the cause, extend the window a third week rather than guessing. Two weeks that agree out of three is a pattern; two that disagree is a coin toss.


Extract the numbers

From that story, pull out a handful of figures per metric. Start with the typical busy-hour range (here: 35–50%). Add the p95 over the window if your tool computes percentiles (here: 58%). That is the value 95% of samples stayed at or below, which politely ignores the freak moments. Add the regular peak and its schedule (65% daily at 08:50–09:10; 60% nightly at 01:00–03:00). And add the quiet floor (3%). Those four or five numbers, plus the shape story in one sentence, are the entire baseline for that metric. Repeat for the rest of the dozen. Budget a quiet afternoon; it is the best-spent afternoon of the project.


Step 4: Write the baseline register


Now write it down — because a baseline that lives in your head is a hunch. A hunch is exactly what you did all this to escape. The document is called a baseline register, and the format that works is a plain table, one row per metric:


MetricNormal range (busy hours)Peak patternp95Quiet floorCapturedNext review
WAN utilization, down35–50%65% at 08:50–09:10 daily; 60% at 01:00–03:00 (backup)58%3%Fortnight ending mid-springIn 6 months, or after WAN change
File server disk (D:)62% used, growing ~15 GB/weekStep-jumps at month-end (reporting exports)——Same windowQuarterly
DNS response, DC110–30 msBrief 60 ms bursts at 09:0035 ms8 msSame windowIn 6 months
Core switch CPU8–15%25% during backup window18%5%Same windowIn 6 months

Two columns deserve a comment. Captured matters because baselines age — a reader must be able to tell a fresh baseline from a fossil. Next review is the hook that keeps the register alive. When a review date arrives or the environment changes, that row gets refreshed. The discipline for that is rebaselining, a guide of its own. Later, when you use the register to set alert thresholds, you will add a threshold column beside these. The guide using baselines to set smarter alerts shows how.


Where should the register live? Anywhere your team already looks: the wiki, the shared documentation folder, the same place as your network diagrams. The only wrong location is a personal notebook or a single admin's home directory. And paste in a small screenshot of each metric's typical week next to its row if your tooling makes that easy. A picture of the shape communicates faster than any sentence about it.


Tip: write the register as if the reader is a competent stranger — a future colleague, or you in two years, which is the same thing. "Normal is 35–50% during business hours, captured over two ordinary weeks" survives handover. "It's usually fine-ish" does not.


Step 5: Sanity-check against reference ranges


Last step, often skipped, occasionally the most valuable: hold your fresh numbers up against published expectations for healthy networks. Your own measurements tell you what is; reference ranges tell you what should be plausible. Guides like healthy ranges for core network metrics and expected latency baselines are built for exactly this comparison. Most of your rows will pass the smell test, and that agreement is itself worth recording: your normal is both measured and reasonable.


Sometimes a row fails. Suppose your fortnight says LAN latency to the file server is "normally" 35 ms — steady, consistent, faithfully repeated both weeks. Meanwhile, the reference says a switched LAN should sit in the low single digits. You have just discovered something important: your baseline is documenting a problem, not health. A duplex mismatch, an overloaded uplink, a creative loop somewhere — something is wrong and has been wrong long enough to look normal. The right response is both-and: keep the honest baseline. It is still your comparison point, and it will prove the fix worked. Open an investigation, and once the cause is fixed, re-measure and update the row. A baseline is a mirror, not a merit badge — and a mirror that shows you a problem has already paid for the whole project.


No tool yet? The lightweight alternative


If you have no monitoring platform at all yet, do not let that postpone baselining forever. A scheduled script sampling a few vitals into CSV files is genuinely enough for a first pass — crude, but crude data beats confident memory. On a Windows server, a task like this every five minutes builds a readable record:


# sample-vitals.ps1 - append one line of vitals per run
$stamp = Get-Date -Format "yyyy-MM-dd HH:mm"
$cpu = (Get-CimInstance Win32_Processor |
    Measure-Object LoadPercentage -Average).Average
$os = Get-CimInstance Win32_OperatingSystem
$memPct = [math]::Round(100 - (100 * $os.FreePhysicalMemory /
    $os.TotalVisibleMemorySize), 1)
$diskFreeGB = [math]::Round((Get-PSDrive C).Free / 1GB, 1)
$pingMs = (Test-Connection 192.0.2.1 -Count 3 |
    Measure-Object ResponseTime -Average).Average
Add-Content C:\baseline\server01.csv `
    "$stamp,$cpu,$memPct,$diskFreeGB,$pingMs"

Register it in Task Scheduler and point the ping at your gateway or another anchor. Let it run for the same two-week window, and open the CSV in a spreadsheet to chart the shapes. You will not get percentile math or per-interface traffic without more work. But you will get day-shapes, week-shapes, peaks, and floors — which is most of a baseline. When you do adopt a real monitoring tool later, it takes over collection and history, and your register format stays exactly the same.


The one-month project plan


Here is the whole method as a checklist you can paste into a ticket and actually finish:


  • Week 1, day 1: pick the starter dozen (steal the table above, adjust for your Tier-1 services). Confirm each metric is being collected at a 1–5 minute interval. Create the empty register with the seven columns.
  • Week 1, day 2: verify data is landing for every metric; fix the two collectors that inevitably are not working. Note any known upcoming oddities (public holiday, office event) in the register's margin.
  • Weeks 1–2 (or a full month if month-end matters): hands off. Let it gather. Peek only to confirm collection health.
  • Reading day: one afternoon. For each metric, narrate the graph: day-shape, week-shape, peaks with times, floor. Extract busy-hour range, p95, peak schedule, quiet floor.
  • Same day: fill the register. Stamp every row with the capture window and a next-review date.
  • Final hour: sanity-check each row against reference ranges; open an investigation for any "normal" that is not healthy.
  • Ongoing: before any significant change, snapshot the affected metrics; when review dates arrive, refresh the rows.

Where to go next


One month, mostly waiting, and you own something most networks never get: a written, dated, defensible record of normal. The register starts paying immediately — every "is this high?" gets answered in seconds — but its two big payoffs are still ahead. First, turning normals into alert thresholds that catch real change instead of noise: using baselines to set smarter alerts. Second, getting fluent in the rhythms your graphs revealed, so expected peaks stop scaring you and real anomalies stand out: weekly rhythms and seasonal patterns. The full set of guides lives in Baselining & Knowing Normal.


Put this into practice with SysPeep Monitor

The gathering step of this method is exactly what SysPeep Monitor is built for. It auto-discovers your devices and collects utilization, CPU, memory, disk, and latency over SNMP, WMI, and SSH. It keeps the history so your two-week window is waiting in graphs when reading day arrives. The free trial installs on any Windows machine — start it on day one of your baseline month.

Download Free TrialLearn About SysPeep