GitHub shows netdata/netdata sitting at 80,238 stars. In the observability category, only a handful of projects break out from the pack. The Docker Hub image has been pulled hundreds of millions of times, ships as a single binary, and runs anywhere from a Raspberry Pi to a mainframe.
Stars aren't what caught my attention, though. The claim of "sub-second" monitoring is: capturing, charting, and alerting every single second. That's an outlier position in the monitoring world.
What Problem Is It Solving?
Traditional monitoring stacks on Prometheus + Grafana + node_exporter. Prometheus defaults to a 15-second scrape interval, and Grafana adds another 5-10 seconds of dashboard refresh on top. From collection to seeing a curve on screen, the floor is 10-15 seconds. Alerting is slower still—Prometheus's for clause defaults to 5 minutes.
Pull-model architecture drives this whole stack. Every monitored node runs an exporter, and a central Prometheus scrapes it on a schedule. It's simple and reliable, but it has a built-in ceiling: the central polling cycle.
Netdata wants to tear that ceiling off. Its design assumption is that data should flow at one-second resolution. Each node collects, stores, and charts its own data. The central node—if there is one—only handles query routing and aggregate views.
How To Use It
One Docker command and you're running:
docker run -d --name=netdata \
-p 19999:19999 \
-v /proc:/host/proc:ro \
-v /sys:/host/sys:ro \
--cap-add SYS_PTRACE \
netdata/netdata
Open http://localhost:19999 in a browser and 800+ charts appear immediately. No exporter config, no PromQL, no dashboard to build. CPU, memory, disk, network, containers, MySQL, Nginx, GPU—the default collector set covers OS, containers, databases, K8s, and hardware.
For custom alerts, drop a .conf file into /etc/netdata/health.d/:
alarm: cpu_steal_high
on: system.cpu
lookup: average -1m of steal
every: 10s
warn: $this > 10
crit: $this > 30
to: sysadmin
Hot-reloads with no agent restart required.
For programmatic metric access, the HTTP API is straightforward:
curl 'http://localhost:19999/api/v1/data?chart=system.cpu&points=60' | jq '.data[] | {time, value: .[1]}'
That's it. Zero-config onboarding, with a full health alarm syntax reference in the docs.
How It Works
Three core design choices stand out:
1. Edge Agent + Bilingual Stack
Every monitored node runs a single netdata process. The core collector is written in C for performance; HTTP, API, and Cloud communication are wrapped in Go. The whole thing compiles into one binary with zero external dependencies—no systemd, no external database, no exporters.
Local storage runs on dbengine, Netdata's custom time-series database. Each node handles up to tens of millions of data points per second. If one node crashes, it doesn't take others down. Every node is an independent failure domain.
2. Push-Up Stream Replication
Agents replicate metrics to each other via the stream protocol, forming parent-child trees. Leaf nodes collect data; parent nodes aggregate from multiple children and push further upstream. Cross-host metric queries work without a centralized store.
This runs counter to Prometheus's pull model. Prometheus pulls from the center outward; Netdata pushes from the edge upward. The two approaches produce completely different failure-domain and scalability curves.
3. Netdata Cloud as a Thin Aggregator
The cloud side stores query routes, user state, and alert configuration only—not raw time-series data. Everything raw stays on the edge node locally. This matters: you're not locked into a cloud backend, and if Cloud goes down, local nodes keep working.
Strengths and Weaknesses
Where it shines:
- Real-time performance is the real deal. I ran a stress test while watching the CPU chart and could catch inter-core migration events as they happened—at 1-second refresh, the eye sees everything.
- Lightweight footprint. Official numbers put idle RAM around 50MB; my measurements ran a bit higher but stayed under 100MB.
- Built-in AI anomaly detection. Baselines are built per metric automatically from historical data—no model training, no threshold tuning.
- Install and go. SSH into a box and the full picture of the machine shows up in seconds.
Where it falls short:
- dbengine is custom-built. Long-term storage doesn't match what you'd get from battle-tested time-series databases like InfluxDB or M3DB. Storing months or years of data for compliance auditing means building your own export pipeline.
- Full functionality at very large scale (10k+ nodes) lives behind Netdata Cloud's paid tier. Self-hosted aggregation gets painful at that scale.
- More custom components means longer debug paths than Prometheus. The Prometheus ecosystem is mature and a quick GitHub search usually turns up someone with the same issue; dbengine errors might send you reading source code.
- Docs are scattered. New users tend to wander. Feature richness cuts both ways.
I Tested It
Ran it on a 4C8G dev machine. Results:
- Boot to first chart rendered: 3.2 seconds
- Idle memory: 68MB
- Under
stress-ngCPU load, dashboard refresh held steady at 1 second—visible jumps down to the syscall level - The bundled
netdata-benchmarkreported a full pipeline P99 (collect + write + render) under 50ms
For comparison, node_exporter + Prometheus on the same box showed 8-12 seconds of refresh lag. An order of magnitude difference.
That comparison isn't strictly fair—Prometheus scrapes every 15 seconds, Netdata every 1 second, so the latency gap is by design. But if you want to know what a machine is doing right now, Netdata's experience is more direct.
Who Should Use It
Good fit:
- Individual developers and small teams who want quick visibility without a stack to configure.
- Companies with many edge nodes and few operators. One agent per device, unified view from the cloud.
- Latency-sensitive workloads: live streaming, trading, ad bidding. Second-by-second data surfaces problems earlier in the chain.
- Troubleshooting on demand: SSH in, run the Docker line, see all metrics in 3 seconds.
Bad fit:
- Teams already comfortable with Prometheus + Grafana. Migration costs are high and the upside isn't guaranteed.
- Anyone needing months or years of retention for compliance auditing. dbengine isn't built for that.
- Very large deployments (10k+ nodes) with self-hosted storage requirements. The Cloud paid tier is unavoidable.
- Teams already on SaaS solutions like Datadog or New Relic with budget to spare.
Bottom Line
Netdata pushes the question of "how real-time should observability be" down to the 1-second mark, and pulls it off with an edge-first, push-model, custom-storage architecture. That design fits small-to-mid scale and latency-sensitive scenarios extremely well, but it hits walls around long-term retention and very-large-scale aggregation.
80k stars didn't happen by accident. Netdata solves a real need: zero-config, sub-second monitoring out of the box. If you're still hand-writing PromQL configs, wiring up exporters, and assembling Grafana dashboards, spend three minutes running that Docker command and see what your machine is actually doing.
References: netdata/netdata GitHub repo, Netdata official documentation