Observability vs monitoring: the debate most often opens with a budget request, while the monitoring in place works. The probes query the servers, the thresholds trigger alerts, the on-call team is notified. What do you gain by “moving to observability”?
Monitoring signals that a foreseen failure has just occurred. Observability makes it possible to understand a failure that nobody had foreseen, without shipping new code to study it. The second does not replace the first: it extends it. It becomes necessary when your system produces failures that nobody was able to imagine in advance, which becomes frequent in distributed architectures. As long as your failures resemble those you already know, monitoring remains the right tool.
Observability vs monitoring: two questions asked of the system
Monitoring starts from a list. Someone decided in advance what had to be checked: a server’s response, a disk’s occupancy rate, the length of a queue, the return code of a process. Each check carries a threshold, each threshold an alert. Monitoring therefore answers a closed question: is what we are watching in its normal state?
Observability refers to a property of the system: no tool provides it on its own. The term comes from control theory: a system is observable when its internal state can be deduced from what it emits. Applied to software, the idea consists of emitting signals rich enough in context (metrics, logs, traces) to answer an open question after the fact: why did this request, for this customer, on this version, fail?
| Monitoring | Observability | |
|---|---|---|
| What you seek to know | Is the system in a foreseen state? | Why is the system behaving this way? |
| Starting point | Checks and thresholds set in advance | Contextualised signals, queried when needed |
| Object looked at | The component: server, database, queue, process | The request that crosses the components |
| What it lets you know | That a known failure has occurred, and where | What distinguishes failing requests from those that succeed |
| What it does not let you know | The cause of behaviour that nobody had anticipated | What the code has not been instrumented to say |
| Who sets it up | Operations, most often without touching the code | Operations and the development teams: part is obtained through automatic instrumentation, the business context is added in the code |
| What makes its cost grow | The number of components and checks | The volume and level of detail of the data |
Monitoring only knows what someone thought to ask it. Observability is only worth what the code has taken the trouble to say.
Monitoring, surveillance, telemetry, observability: untangling the vocabulary
The vocabulary sustains the confusion. Asking whether to choose “observability or monitoring”, or comparing “observability vs surveillance vs telemetry”, is asking the same question in other words.
- Monitoring and supervision overlap in French usage: the latter most often translates the former, even though the English-language literature gives monitoring a broader meaning, which includes the collection and display of measures internal to the system.
- Surveillance is the generic term, and the literal French translation of monitoring: watching a system continuously, whatever the method.
- Telemetry refers to the raw material: the measures emitted by the system and their transport to a collection point. Monitoring and observability both consume it.
- Observability refers to the result: the ability to explain the system’s behaviour from this telemetry.
Telemetry is therefore a material, monitoring a use, observability a quality that the system has or does not have. No tool provides it on its own.
When monitoring is enough, and the signs that it no longer is
Monitoring is enough when the failure modes are known and few in number. This is often the case for a monolithic application, a software package whose code you do not control, a batch process, an infrastructure whose topology rarely changes. A failure there has an address: a server, a database, a network link. Knowing which component is failing is almost knowing what to repair. Investing in the observability of such a scope generally pays back less than improving its monitoring.
The situation changes with distributed systems. A user request crosses several services, message queues, third-party interfaces. Instances appear and disappear as the load varies, and production releases follow one another. Failures become partial: the service does not go down, it fails for some customers, on some journeys, at certain times. Each component taken in isolation is in its normal state, and no threshold is crossed.
Four signs indicate that this limit has been reached:
- incidents are reported by users or by support before being reported by an alert;
- diagnosis requires bringing together several teams, each of which demonstrates that its component works;
- each incident ends with the addition of a dashboard or a threshold, which will not help with the next one;
- the cause is established through successive hypotheses and restarts, rarely by reading the data.
If you recognise none of these signs, the best investment remains your monitoring: fewer alerts, better tuned.
What the switch requires in terms of organisation and costs
Instrumentation is development work. Automatic instrumentation of libraries and agents provides a first level of traces without modifying the code. The business context (customer, version, journey step) and the propagation of the request identifier across message queues and third-party services remain to be added by the teams. This work competes with features in the teams’ product backlog: without explicit arbitration, it does not get done.
Conventions matter more than the tool. Service names, common attributes (version, environment, customer), log format: without a shared rule, the signals do not cross-reference. An open standard such as OpenTelemetry describes how to produce and transport traces, metrics and logs, independently of the tool that exploits them. These conventions are better provided by the internal platform than reinvented by each team, which falls under a DevOps and platform engineering approach.
Cost mainly follows data volume. Detailed logs, traces of every request, metrics broken down by many dimensions: spending grows with traffic, level of detail and retention period. It is managed through explicit choices: sampling traces, limiting metric dimensions, differentiating retention periods. Billed on usage, it is tracked like the other variable cloud expenses, with FinOps practices.
Skills change. Reading a dashboard and formulating a question in data are two distinct skills. The on-call team must be trained in investigation, and developers must take part in diagnosing their own services.
Alerts are rebuilt. Observability gives its full measure when the alert concerns what the user experiences rather than the state of a component. This is the logic of service level objectives, presented in our entry on the definition of SRE.
The pitfalls of switching to observability
- Considering the matter closed once the tool has been bought. The tool stores and displays. It does not add to the code the context it lacks.
- Collecting everything “just in case”. Volume inflates the bill and drowns the useful signal.
- Dismantling monitoring. Known failures continue to occur, and a simple check remains the cheapest way to see them.
- Keeping three sealed tools for three signals. If you cannot move from a metric to a trace, then to the corresponding logs, you have three monitoring systems and not observability.
- Forgetting what the signals carry. Logs and traces easily contain identifiers or customer data. When personal data are involved, the GDPR, Regulation (EU) 2016/679, applies to their collection and retention as to any other processing.
Monitoring and observability: what to remember before deciding
Monitoring watches the known, observability explains the unforeseen. The choice depends on your architecture: a stable, centralised system makes do with good monitoring, a distributed system that changes often ends up requiring observability. The switch is an instrumentation and organisation workstream before it is a tooling matter.
The prudent way to start is narrow: a single critical journey, instrumented end to end, on which you compare how a diagnosis unfolds before and after. This is the type of workstream our SRE and observability offering covers: service level objectives, instrumentation, alert redesign and incident management.