The problem

I'm part of a systems support team, where alongside diagnostics and incident troubleshooting I also do development work. One of the systems we support ingests telemetry from a large fleet of IoT trackers installed on vehicles. Every few seconds each device reports its coordinates and status parameters. An internal processing service turns that raw stream into higher level business objects: events, incidents, trips, that the rest of the platform consumes.

The system has been in pure maintenance mode for years. No development budget, no vendor to call. It still has to be supported though, people use it every day.

Every so often one device develops a hardware fault and starts “spamming”: emitting an abnormal volume of points or malformed events in a short window. That degrades the processing pipeline not only for that device, but for everyone sharing it.

Finding the culprit used to mean a first line engineer manually pulling several raw tables for the relevant day (events, incidents, raw points), cross referencing them by timestamp and device ID, and eyeballing the result for anomalous patterns.

With the events table alone running millions of rows a day, that was a 6 to 7 hour job, basically an entire shift, with no guarantee of actually finding the source.

The solution

I designed and built a small internal web tool that automates this triage.

Stack: a Node.js/Fastify service handles uploads, job orchestration and progress reporting. A set of Python scripts do the actual line by line parsing and aggregation. The frontend is React. There is no live database connection: the tool consumes the same flat file dumps engineers already know how to export, and that was a deliberate choice. Adding zero new infrastructure or DB access mattered as much as the analysis itself.

Here's the flow:

A first line engineer exports a dump exactly the way they already do it manually, no new export format to learn.
They drop the file onto the portal through a simple web interface.
The backend streams it line by line instead of loading it into memory, because a multi‑million‑row dump has to run on a support engineer's laptop, not a data processing cluster.
The data gets aggregated down to what actually matters: which device or devices show abnormal patterns, over what window, with what signature (burst frequency, stale timestamps, invalid GPS fixes, frozen coordinates, and so on).
The output shows the specific problem with all the data needed to understand it, so a first line engineer immediately knows what to do next: temporarily disable the device, move it to a test loop, or initiate an on‑site repair, instead of a wall of raw rows.

The tool has grown into a small family of report types (data freshness scoring, burst detection for two different entity types, log analysis, a couple of cross dump reconciliation reports), and I'm actively expanding it, aiming for more than twenty report types that cover the recurring diagnostic scenarios our first line runs into. Reports show a live progress bar computed from actual row counts instead of a spinner, and for point level data there's an animated map view that redraws a device's GPS trace so you can visually confirm the anomaly instead of just trusting a number.

Why it was harder than it sounds

The interesting engineering problems weren't in the UI.

Streaming instead of batch processing. Multi million row dumps had to be processed without loading them wholesale into memory, on modest hardware, in a reasonable amount of time.

Aggregating without losing the signal. The easy version just counts rows per device. The useful version buckets by time window, tracks run length of repeated or frozen coordinates, classifies write lag into severity tiers, and merges adjacent bad windows into readable ranges, so the output points at why a device is misbehaving, not just that it is.

Zero new dependencies. The target environment had no route to install third party packages, so the Excel export is generated by hand assembling a valid.xlsx file as a zip of XML parts, no spreadsheet library involved at all.

Zero onboarding cost. Any first line engineer had to be able to use it right away, with the export they already knew how to produce. Anything that required learning a new format or understanding the schema would have defeated the whole point.

Results

	Before	After
Time to triage one incident	6 to 7 hours, a full shift	~15 min to export plus 10 to 20 min to diagnose
Who can do it	An engineer who knows the DB schema in depth	Any first line engineer
Dependency on vendor or budget	Full, no changes possible	None

The time saved isn't just convenience. It's hours of first line capacity freed up per incident, and a whole category of case (device level event spam) that used to get escalated to the second line now gets resolved without leaving the first line at all.

What's next

I'm planning to open source a generic version of the core, stripped of anything domain or infrastructure specific, since the streaming aggregation approach and the time series anomaly detection logic seem generally useful for anyone maintaining a legacy system with high volume telemetry and no budget for a proper rewrite.

Happy to go deeper on any part of this in the comments, especially interested in hearing from anyone who's had to diagnose systems they weren't allowed to touch.

How I Built a Diagnostic Tool for a Legacy System With No Dev Budget, and Cut Incident Triage From 6 Hours to 20 Minutes