Skip to main content

Netdata Design

Observability can be simpler and stronger at the same time. We built Netdata to make it so, by rethinking every layer: how data is collected, stored, scaled, analyzed, queried and operated, and how people and AI use it.

This document states what we believe about observability and how Netdata's design delivers it. Welcome to Netdata explains the outcomes, and the Complete Product Description lists every capability.

The problem we set out to solve​

Observability promises understanding. Too often it delivers a bill, a project and a partial picture.

  • It is expensive, so it is partial. When every metric, log line, span and flow costs money to move and store, teams choose what to keep, and incidents happen in what they left out.
  • It is centralized, so it strains at scale. Moving all data to one place makes that place the bottleneck, the single point of failure and the largest line in the bill.
  • It belongs to experts. Query languages, hand-built dashboards and databases to run keep understanding in the hands of a few people, and incidents wait for them.
  • Its intelligence adds noise. Machine learning used as an alert engine produces more alerts to tune, not more understanding.
  • Its data lives somewhere else. Data held outside your infrastructure is data you pay to reach and cannot easily take back.

What we are building​

Netdata is observability for every system, network and application: complete, real-time and automatic, usable by everyone on the team and by AI, at a cost that never forces a choice about what to watch.

One product, one data model and one interface cover:

  • Infrastructure: systems, containers, Kubernetes, virtualization, hardware, and the applications and services running on them.
  • Applications: distributed tracing, service maps, and request rate, errors and latency for every service.
  • Digital experience: real user monitoring, synthetic browser journeys and performance audits.
  • Networks: devices, topology, traffic flows, traps, BGP and licenses.
  • Databases, logs and cloud services, and endpoints and edge devices.

What we believe​

Understanding over traffic lights​

Monitoring tells you that something is wrong. Observability tells you why. Netdata gives you both, from the same data.

An alert tests a hypothesis someone formed in advance: is the disk filling, is the service answering, is latency above the limit. Every system needs that. But incidents are rarely caused by what someone wrote a check for, and a red light does not explain itself. Observability is open-ended: it answers the questions you only think of in the middle of an incident, and lets you follow the answer from one component to the next until you reach the cause and its impact.

How the design delivers it:

  • Alerts written once, applied everywhere. More than 1,100 stock alerts are templates that attach to every matching instance as soon as it appears. Your own alerts work the same way, on any metric, written as code, created from the dashboard, or generated by AI and tested against your own history before they are deployed.
  • Every alert opens into the full picture: every metric of the affected systems, scored for anomalies, next to their logs, traces and live views of processes, connections and services.
  • Alerts run where the data lives, so they keep working through any outage outside that hub.

Everything, every second, affordably​

The data you did not collect is the data your next incident needs. We collect everything, every second, and we engineer the cost down until choosing what to watch is no longer necessary.

When collection and storage are expensive, teams sample, aggregate early and keep a shortlist of metrics. Each of those choices removes exactly the detail an unexpected incident needs. A platform that makes completeness unaffordable defeats its own purpose.

How the design delivers it:

  • Per-second resolution by default, the resolution of the console tools engineers reach for during incidents, with history and machine learning added.
  • Everything Netdata can reach is collected and charted from the first minute, with no project to finish first.
  • Every layer is engineered for cost: about 0.6 bytes per sample on disk, long-term history in tiers that keep the peaks, and no ingestion pipeline to pay for.

Independent hubs, not a central database​

Data should stay close to where it is created. Netdata concentrates it in independent hubs that you place where they make sense, and Netdata Cloud unifies and correlates them all.

Centralizing every sample at full resolution is what makes high fidelity expensive and fragile. We distribute the work instead: the code that collects, stores, analyzes and queries runs next to the data.

How the design delivers it:

  • Hubs for every kind of data. Netdata Parents concentrate metrics. Netdata Agents concentrate network devices over SNMP, server hardware over Redfish, logs, traces and traffic flows. You decide where each hub goes: per site, data center, region, team or customer.
  • Hubs are independent. They share nothing and never wait for each other. Capacity grows by adding hubs, and a problem in one hub stays in that hub.
  • Scale by adding hubs. Netdata scales to 100,000+ nodes. A Parent handles about 500 nodes or 2 million metrics per second, and you grow by adding Parents.
  • Netdata Cloud makes them one. It routes every question to the hubs that hold the answer and correlates the results into one view of metrics, logs, traces, flows, topology and devices. It is not in the data path: the hubs keep collecting, storing, analyzing and alerting without it.
  • Queries run where the data is, in parallel across all hubs, so adding hubs adds query capacity too.
  • Missing data is shown as data. Every chart states which sources answered and which did not, so a partial answer is never mistaken for a complete one.
  • Your data stays on your infrastructure as a natural result of the design.

See Scalability for sizing, placement and high availability.

Meaning at collection time​

A metric is only useful when its meaning travels with it. Netdata gives every piece of data its meaning when it is collected, so dashboards build themselves and every chart is correct.

Most of what teams run is built from the same finite set of components: operating systems, databases, web servers, message brokers, containers, network devices. Netdata's collectors carry the knowledge of each one: what is measured, the units, which series belong together, how to aggregate them and which labels describe each instance.

How the design delivers it:

  • Dashboards build themselves, with the same structure on every node, device and service.
  • One data model, NIDL, behind every chart, alert and query, so a wrong chart is a bug we fix, not a mistake you made.
  • Your own data gets the same treatment. Prometheus and OpenTelemetry metrics are structured through profiles, and application traces become per-service performance charts and a service map, with no dashboard work.

Machine learning as evidence, not alerts​

Machine learning failed in observability as an alert engine: it needs more time tuning than the alerts it raises are worth. We use it for what it does uniquely well: evidence of what changed, what changed together and how strongly.

How the design delivers it:

  • Every metric, scored every second. Netdata trains 18 models per metric and flags a sample only when all of them agree. The result is stored with every sample, so anomaly rates exist for any metric, any time window and any history.
  • Correlations nobody would think to look for. During an incident, anomalies appear together across the components a problem touches. Netdata ranks them across everything it monitors, and the cause usually sits among the first few dozen.
  • Dependencies discovered from behavior. Components that keep turning anomalous together reveal how they depend on each other, including dependencies nobody documented.
  • Nothing to train or tune. Models train on their own and keep adapting as your systems change.

Alerting stays with rules people can read and reason about. Anomaly rates are data like any other, so a team can use them in a rule where it chooses to.

AI at the core​

AI is not an add-on to Netdata. Machine learning runs inside every Agent and Parent, a scoring engine ranks what matters, and AI reasons over that evidence. Together they deliver automated root-cause and impact analysis.

How the design delivers it:

  • Machine learning in the core. Every Agent and Parent models every metric it holds and scores every sample for anomalies as it is collected. There is nothing to export, train or configure.
  • A scoring engine that finds what matters. For any time window, Netdata scores every metric across the infrastructure by anomaly severity, by how much it changed against a baseline, and by what changed together with it, and returns a ranked list. The cause usually sits within the first few dozen of thousands of metrics. See the Anomaly Advisor and Metric Correlations.
  • AI that starts from evidence. Netdata AI and any AI assistant receive the ranked evidence: what stands out, how strongly and what changed together, next to live logs, traces, topology, processes and connections. AI does not have to guess which of millions of series to check, and every metric it reads arrives with its meaning.
  • Automated root-cause and impact analysis. Netdata AI investigations trace any question or time window from symptom to cause and to everything it affected, in minutes, on demand or on a schedule.
  • Open to any AI. Every Agent, Parent and Netdata Cloud runs an MCP server, so the same evidence and the same scoring are available to the AI assistants your team already uses, under the same access controls as the dashboard.

Expertise built in​

Healthy systems need everyone who builds and runs them to see what is happening, not only a few specialists. Netdata moves the expertise into the product.

How the design delivers it:

  • No query language. Every chart is an analysis tool you operate by pointing and clicking: group, filter, compare periods, drill down and correlate. Any question can also be asked in plain language, through Netdata AI or any AI assistant.
  • Nothing to administer. The database is part of every Agent and Parent, retention manages itself, and every Agent updates on its own. Teams run Netdata like any other service, without dedicated specialists.
  • Knowledge of every technology. Stock alerts, collection profiles and dashboards carry the knowledge of each technology, so a team can operate components it is not expert in.

Configured your way​

Netdata fits the way you already manage infrastructure: as code, from the dashboard, or both.

How the design delivers it:

  • Automatic first. Discovery finds what runs and stock settings cover it, so most components need no configuration at all.
  • As code. Configuration files are deployed and versioned with your provisioning systems.
  • From the dashboard. Dynamic configuration creates and changes collection jobs and alerts on any node, without restarts, reaching every node through its Parents.
  • Mixed. Keep the base in code, and handle credentials, thresholds and secondary systems from the dashboard. See fleet configuration management.

Open, and yours​

Everything that collects, stores, analyzes, alerts on and queries your data is open source, speaks open standards, and runs on your infrastructure.

How the design delivers it:

  • An open-source engine. Collection, the database, machine learning, alerting, streaming, the APIs and the MCP server are open source (GPLv3 or later). Every deployment, from one node to the largest fleets, runs the same engine.
  • Open in, open out. Netdata takes in OpenTelemetry, Prometheus, StatsD, SNMP, NetFlow, IPFIX and sFlow, and exports to the systems you choose. Your data is never locked in.
  • Your infrastructure, your choice of control plane. Netdata Cloud runs as SaaS or entirely on your premises, including air-gapped environments.

The trade-offs we chose​

Every design makes trade-offs. These are ours, made on purpose.

  • We move the code to the data, not the data to the code. A fleet-wide query fans out to the hubs and comes back already aggregated, so nothing has to be shipped, ingested and indexed in one place first.
  • We collect everything and engineer the cost down, instead of asking you to predict which data the next incident will need.
  • We give data its meaning when it is collected, so Netdata carries the knowledge of each technology instead of leaving every team to rebuild it.
  • We keep machine learning out of the alert path, and use it where it has no equal: as evidence for people and AI.
  • We keep the engine open, so the core of your observability never depends on a vendor's goodwill.

What it means for you​

  • Answers from the first minute, with every system, network and application monitored, charted and alerted on automatically.
  • The cause, not only the symptom, because complete data, anomaly evidence, logs, traces and live views sit on one timeline.
  • One product instead of a toolchain, from infrastructure and networks to applications and user experience.
  • A cost that does not punish completeness, because cost was engineered out of every layer.
  • Root cause and impact found automatically, by machine learning, a scoring engine and AI working together.
  • Everyone on the team can investigate, from the same evidence.
  • Your data stays yours, on your infrastructure, scaling by adding hubs.

Do you have any feedback for this page? If so, you can open a new issue on our netdata/learn repository.