Blog

SNMP Isn't the Problem. Treating It as Sufficient Is.

Jayakumar Kadirvelu |
Aug 9, 2026

I designed and implemented SNMP MIBs at Cisco for 5+ years.

SNMP isn't the problem. Treating it as sufficient is.

I want to be clear about where I'm standing when I say that. I'm not critiquing SNMP from the outside. I sat in the chair where the objects got defined: deciding what an agent would expose, what would be readable, what would be notifiable, and what would never make it into the MIB at all. That work gave me real respect for what SNMP was built to do.

It also showed me exactly where its design intent ends. And most monitoring conversations I have today in my current role assume it ends somewhere much further out than it actually does.

SNMP Won on Ubiquity, Not Elegance

Let's give the protocol its due.

SNMP has survived four decades of infrastructure turnover, and it did that for a simple reason: every vendor shipped an agent, and every management system could consume it. It was cheap to implement, cheap to integrate, and it worked over the network you already had.

Walk into any mission-critical facility today and it's still the common language:

• Public safety BDAs and commercial DAS head-end equipment

• Rectifiers, power plants, and battery strings

• UPS, rack PDUs, and branch circuit monitoring

• CRAC/CRAH units, chillers, and rack-level environmental sensors

• Optical transport and Ethernet switching

None of these speak SNMP because it was the most elegant option. They speak it because the economics made it inevitable. That's not a criticism — that's a genuine achievement. Interoperability at that scale is rare.

What It Was Designed to Be — and What It Wasn't

Here's the part that gets lost.

SNMP is a management framework. It was designed to retrieve managed state, modify selected state, and asynchronously report defined events — on networks where bandwidth was expensive, and agents ran on very modest hardware. The design assumptions were small responses, low overhead, and a management system asking or being told on a schedule someone chose.

It was never scoped as a high-resolution streaming telemetry architecture. Nobody designing the object model was thinking about time-series analysis. We were thinking about whether a value could be fetched reliably without loading the device.

SNMP got pressed into telemetry duty later, by an industry that needed telemetry and already had SNMP everywhere. That's a reasonable thing to have happened. But the framework didn't change its nature just because we changed our expectations of it.

Polling: Sampling Versus Retained Evidence

Most SNMP monitoring is polled. A manager walks a set of OIDs on an interval — commonly five minutes, sometimes fifteen, occasionally one.

The usual complaint is that the interval is too slow. The real issue is more specific, and worth getting right.

A short event can still leave durable evidence behind. An incremented error counter. A latched alarm. A last-change timestamp. A vendor state-history object. Any of those survive until the next poll, and a collector that knows to read them recovers the event after the fact, even though the instantaneous state has already returned to normal.

The loss happens when a condition begins and clears entirely between samples and leaves nothing behind — no counter, no latch, no timestamp, no notification. At that point, the evidence was never created, and nothing downstream can reconstruct it. That's not a limitation of your analytics. It's a gap in what was captured.

Two examples from my world:

A public safety BDA drops into oscillation, degrades the downlink, and self-corrects in ninety seconds. If the unit latched a fault or incremented an error counter, you have something to find. If it didn't — and for transient RF conditions that clear on their own, plenty don't — you have two clean polls and nothing in between. The firefighter who couldn't raise dispatch from that stairwell isn't in your data.

A battery string, a UPS string backing a data center row, or a DC plant at a cell site, sags under load, recovers on float, and repeats this over weeks. Here the problem isn't a missing event; every poll returns a valid reading within range. The problem is what you sampled. You caught the recovery and not the sag, so the record shows a healthy string right up until it isn't one.

In both cases, the monitoring system is working correctly and reporting nothing wrong. That's the uncomfortable part.

Traps: Real-Time, but Only for What Someone Instrumented

This is where the conversation usually stops, and it shouldn't — because polling is only half of SNMP.

Traps are the asynchronous half. A device pushes a notification the moment something changes, without waiting to be asked. That's genuinely valuable, and it closes the latency problem polling creates. Any fair assessment has to credit it.

But traps don't resolve the underlying limitation, and this is the part I can speak to directly:

A notification only exists if someone decided, in advance, to define it. I wrote those definitions. Every NOTIFICATION-TYPE in a MIB represents an engineer making a judgment call about what a future operator would want to know. If a vendor never instrumented gradual battery degradation as a notifiable event, there is no trap for it in that release. Firmware can add notifications later — but for any given implementation in the field, the event vocabulary was frozen at MIB design time, by someone guessing at failure modes they hadn't seen yet. And in this industry, the gap between "firmware could be updated" and "firmware was updated" is measured in years.

Notifications can carry far more than thresholds — but in practice, they rarely do. A trap can report a cold start, an authentication failure, a configuration change, a topology event, or any condition the instrumentation was built to recognize. That's a wide vocabulary in principle. Having reviewed a lot of infrastructure MIBs written by other people, what I see in practice is much narrower: notifications cluster around discrete faults. Power loss. Alarm asserted. Link down. Threshold crossed. What almost never appears is a notification describing a trajectory — a value that has been moving in the wrong direction for six weeks without crossing anything yet. That isn't an oversight by any one vendor. It's what the model invites.

Delivery is asymmetric, and the asymmetry matters. SNMP polling and trap traffic runs over UDP, which was a deliberate and defensible choice — connectionless, low overhead, no session state for the agent to maintain, and it still functions on a degraded network where a handshake might not complete. But the consequence of a dropped datagram isn't symmetric. Lose a poll response and you miss one sample; the next cycle recovers. Lose a trap and the event is gone permanently — no sequence number, no gap to detect, nothing to backfill. Informs add acknowledgment and retry, but adoption is uneven and a lot of field-deployed gear only emits v2c traps.

Silence isn't an event. No device sends a notification saying "I have stopped functioning." Absence of signal is only detectable by polling or heartbeat. Which is why every trap-based system in production still has a poll loop underneath it.

Trap storms don't reveal root cause on their own. A fiber cut upstream of a commercial DAS head-end affects every active node downstream. Dozens of devices fire simultaneously, the receiver saturates, and the actual cause — one link — is somewhere in the flood. A capable management system can dedupe, suppress, and correlate its way out of that using topology and dependency knowledge. And that's exactly the point worth noticing: it can. But that intelligence doesn't come from the protocol. It has to be built in the layer above it.

And then there's the pattern the industry invented to work around the sparseness: trap-directed polling. A trap arrives, and the management system immediately polls the device because the varbinds alone are too thin to act on. That workaround is a standing admission that notifications were never intended to carry full context.

And No, v3 Doesn't Change This

The reply "use v3" is worth addressing directly as well.

SNMPv3 was a genuine and necessary improvement, and it's a broader architectural framework than people give it credit for. But its practical impact landed overwhelmingly in one dimension: security and administration. The User-based Security Model, authentication, encryption, view-based access control. It fixed a real catastrophe — v1 and v2c community strings were cleartext, and treating that as adequate access control was indefensible long before v3 shipped.

What v3 did not do was turn SNMP into a streaming telemetry system, or supply time-series retention, trend evaluation, or historical context. Informs arrived in v2c, not v3, so v3 didn't even improve delivery reliability.

Three major versions in, what got fixed was security — not the event model. If the industry had experienced the sampling-and-thresholds ceiling as a defect in the protocol, some version would have addressed it. None did. Because it was never a defect. It was the scope.

The Bridge

Polling gives you sampled state, plus whatever evidence the device happened to retain. Traps give you the events someone instrumented in advance.

Both answer what is it now or what just happened. Neither answers where is this heading.

Fragmentation: The Tax Nobody Talks About

"SNMP-compatible" is not the same thing as interoperable, and this is the gap that costs the most in practice.

Two rectifiers from two vendors both report battery voltage. One exposes it under its own enterprise OID branch in deci-volts. The other uses a different branch, a different scaling factor, and a different definition of which measurement point counts. Both are standards-compliant. Neither is comparable to the other without work.

Same story one rack over. Two PDUs both report power draw — one gives per-outlet current in tenths of an amp, the other only aggregate inlet watts, with no per-outlet breakdown at all. You can't sum them into a rack-level number you'd trust, let alone a row-level one.

I've seen this from both sides. I wrote MIBs that someone downstream had to interpret, and I've reviewed enough MIBs from other vendors to know the variance isn't marginal — the same physical measurement gets modeled several different ways, with different structure, different units, and different implicit assumptions about what an operator would care about. Each one is internally coherent. Across a portfolio, they don't reconcile.

Multiply that across every device class and every integration becomes a normalization project — mapping OIDs, resolving units, reconciling semantics, and maintaining all of it through firmware revisions.

To be fair to the standard: SNMP did standardize a great deal. The SMI, MIB-II, and the standard MIBs are real achievements, and they're the reason a generic manager can talk to unfamiliar hardware at all. What the industry never produced was a universal semantic model spanning vendor-specific instrumentation. The framework is standard. The meaning inside the enterprise branches isn't.

Where the Industry Went — and Where It Didn't

Worth being precise here, because the picture isn't uniform and the pieces are often lumped together incorrectly.

Routing and switching largely moved toward model-driven management: YANG as the modeling language, OpenConfig providing vendor-neutral models, NETCONF and RESTCONF for structured configuration and retrieval, and gNMI over gRPC for configuration plus subscription-based streaming telemetry. Different layers doing different jobs — not four names for the same thing.

Physical and facility infrastructure mostly didn't follow. It stayed on SNMP, alongside Redfish displacing IPMI at the rack level, Modbus and BACnet in building systems, and DNP3 in utility environments.

The data center runs the same split. Servers moved to Redfish, and the compute layer is increasingly well instrumented. The facility underneath it — UPS, PDUs, CRAH units, leak detection, door contacts — is largely SNMP, and often SNMP through a vendor gateway that flattens whatever richer data existed upstream. Which means the fastest-growing power density in the industry is being monitored, at the facility layer, by a framework designed when a rack drew two kilowatts.

Telecom is the clearest illustration, because the split runs straight through it. The same operator streaming gNMI telemetry off its core routers is polling a BDA in a parking garage every five minutes over SNMP. Transport moved. Outside plant, DAS head-ends, power plants, and battery strings did not.

But I'd resist making this an old-protocol-versus-new-protocol story, because that's not the actual dividing line. SNMP can feed an excellent monitoring platform. gNMI can feed a poor one. Higher-resolution, better-structured data raises the ceiling on what's possible. It doesn't supply the analysis. If someone tells you SNMP is legacy, they're probably right about their routers, wrong about the power plant, and answering a different question than the one that matters.

Thresholds Are a Symptom, Not a Strategy

Once you see the event model clearly, a lot of monitoring behavior stops looking like a product choice and starts looking like a consequence of where the intelligence was — or wasn't — built.

If what reaches your system is a value on an interval plus a notification when that value crosses a preconfigured line, thresholds are the only alarm logic you've been handed. Anything more requires work the protocol doesn't do for you: retaining history so a value has a trajectory, normalizing so measurements are comparable across vendors, correlating so related events resolve to a cause.

Nothing in SNMP prevents any of that. But nothing in SNMP provides it either. Which is why "we have SNMP monitoring" so often means, in practice, "we have thresholds on polled integers" — not because the teams running those systems chose thresholds, but because that's what arrives if nobody builds the layer above.

So What Should Modern Monitoring Do With SNMP?

Not replace it. That argument doesn't survive contact with a real site — the installed base is enormous, the service lives are long, and SNMP is often the only interface a device offers.

Treat SNMP as one source of evidence, and then do the work it was never designed to do:

• Normalize across vendors. Example: battery voltage means the same thing regardless of who built the physical devices

• Retain history, so a value has a trajectory and not just a current state

• Evaluate trend, so a slow drift toward a threshold is visible before it becomes a crossing

• Correlate across subsystems, so a trap storm resolves to a cause instead of a flood

• Detect silence, because the absence of data is itself information

Put concretely: SNMP can tell you that an amplifier crossed a threshold. What you actually need to know is whether that crossing is isolated, correlated with upstream equipment, the endpoint of a six-week degradation, or one symptom of something larger. That question is answerable — but only above the protocol.

That's the solution we've been working on at ECSite, Inc 's ECMonitor.ai : not replacing SNMP, but treating it as one input among several and applying trend analysis on top of it, which goes beyond what most legacy, threshold-based systems do today.

I'll cover other collection models in future posts — including DNP3, which buffers and time-stamps events at the source, addressing a problem SNMP left to the management layer.

I still think SNMP is one of the more successful pieces of infrastructure engineering in the last forty years. It did its job. My concern is with what we've assumed it does on our behalf.

So a question for the practitioners reading this:

When did a notification last tell you something was about to fail — rather than that it already had?