Observability vs monitoring: what the difference actually means
The practical difference between monitoring and observability, covering known failures versus unknown ones, the three pillars of logs, metrics and traces, what OpenTelemetry changed, and how much each costs to operate.
On this page
Observability is the ability to answer new questions about a system's behavior from the telemetry it already records. Monitoring is the narrower practice of alerting on failures a team predicted in advance, usually when a metric crosses a threshold. That's the core of observability vs monitoring: monitoring tells you something you expected went wrong, and observability helps you find out why when it's something nobody expected.
Monitoring vs observability: known failures versus unknown ones
A multi-tenant SaaS platform runs order-count, checkout-latency, and error-rate dashboards averaged across every tenant, and every panel is green. The failure hits one tenant out of thousands and barely moves an aggregate number. A customer on an older Android build hits a payment method their app version handles incorrectly, so checkout throws a client-side error the server never sees. Support gets the complaint before engineering gets a signal.
Monitoring can't catch that, because it's built ahead of time: someone picks the metrics that matter, sets a threshold, and waits for it to trip. It works for failure modes someone thought to name. For the ones nobody named, there's no panel. Observability swaps the pre-built dashboard for raw telemetry an engineer can query after the fact, asking a question the system was never wired to answer: show every checkout on this app version in the last hour, broken down by payment method.
The three pillars of observability
Three kinds of telemetry cover most of what observability tooling collects.
- Metrics are numbers over time: request rate, error rate, latency, queue depth. Cheap to store because they're pre-aggregated, and usually what a dashboard is built from. They can't tell you which request failed.
- Logs are timestamped records of discrete events, one line per thing that happened: which request, which user, which error. That detail is what metrics throw away, and it's also what makes logs expensive at scale, since verbose logging on a busy service can outgrow every other telemetry cost combined.
- Traces follow a single request across every service it touches, timing each hop as a span. They're the only one of the three built to show where in a distributed call chain the time went, which is exactly the gap in the checkout example above. Storing every span for every request gets expensive fast, so traces are usually sampled rather than kept in full.
You need all three. A metric flags that something is wrong, a trace shows roughly where, and a log fills in the detail once the search is narrow enough to read one. The three-pillar model is still the standard shorthand, though OpenTelemetry is adding newer signals such as continuous profiling, which may end up as a fourth.
What OpenTelemetry changed for observability
Before OpenTelemetry, a team instrumenting a service for tracing chose between two competing open-source projects, OpenTracing and OpenCensus, whose tooling rarely worked together. The two merged in 2019 to form OpenTelemetry, which the Cloud Native Computing Foundation accepted as a sandbox project that year. It reached Graduated status, the CNCF's highest maturity tier, in May 2026.
In practice, instrumentation is no longer tied to one observability vendor. Code gets instrumented once, against the vendor-neutral OpenTelemetry specification and the standardized distributed headers defined in the W3C Trace Context specification, and the resulting logs, metrics, and traces ship to any backend that accepts the OpenTelemetry protocol (OTLP). Switching backends used to mean re-instrumenting the codebase; now it mostly means changing an export destination.
What observability costs to run
Observability tooling is usually priced on volume, and volume grows faster than most teams expect once instrumentation gets thorough. Most of the bill comes down to cardinality, retention, and sampling.
Cardinality is how many unique combinations a metric can produce. Tag a request-count metric by service name alone and it might have a dozen values; add user ID too and it can hit millions, and most backends charge more as cardinality climbs.
Retention is how long data sits before deletion. Teams usually keep logs and traces for weeks and metrics for years at lower resolution, since storage cost scales with volume and duration.
Sampling decides what fraction of traces get recorded. Full capture is the most complete option and, at scale, often the most expensive by a wide margin. Most teams sample a fixed share of ordinary traffic and force full capture for anything that errors or runs slow.
Instrumentation mistakes that get expensive
These habits produce the bills nobody planned for.
- Instrumenting every service and field before anyone asks what will get queried. The cardinality cost stays invisible until the bill arrives, usually driven by a tag nobody remembers adding, a raw user ID or an unbounded request path.
- Writing a log line as a prose sentence, "payment failed, retrying," instead of a structured event. It reads fine in the moment, but there's no field to filter or group later, so months of logs become text nobody can search.
- Routing alerts to a channel with no owner. A page nobody answers for gets muted within weeks, and the one alert that mattered rides through the same silence as everything else.
- Adding sampling only once the bill forces the conversation, instead of deciding it alongside the instrumentation itself. Doing it after the fact means guessing which discarded traces might have mattered.
When teams outgrow basic monitoring
A service with three or four known failure modes doesn't need much of this. A handful of threshold alerts covers it; building out tracing is effort spent on a problem the team doesn't have yet.
The trigger is usually one of three changes. A monolith splits into a dozen microservices, and each split is a new integration point, so a slow checkout can no longer be traced to one dashboard once the request crosses eight services. A contract adds a regulated uptime commitment, so a complaint now comes with a clock attached. Or an incident takes two engineers three days to root-cause because nobody can reconstruct what a specific request did, only that something failed somewhere in the chain.
Architecture matters more than headcount here. A ten-person team running microservices under a regulated uptime commitment needs this sooner than a two-hundred-person team running one monolith. Getting there is mostly an instrumentation problem: deciding what to trace, how long to keep it, and where the sampling line sits. Custom software development and product development engagements run into this at that scale. If you're not sure whether you've reached that point, software development consulting can help you check.
Frequently asked questions
Observability is how well you can work out what a system is doing, and why, from the logs, metrics, and traces it already records. If you can answer a brand-new question about a production problem without shipping new code first, the system is observable.
No. Monitoring is one input into an observable system, the alerting layer built on top of metrics, logs, and traces. A system can have excellent monitoring and still not be observable, because monitoring only answers questions someone thought to ask in advance. Observability lets a team ask a question it never anticipated and still get an answer from data it's already collecting.
Usually not right away. Most teams add tracing and structured logging alongside their existing dashboards, since metrics already cover one of the three pillars of observability. Tooling tends to converge over time anyway, as vendors fold tracing and log analysis into products that used to be metrics-only.
APM, or application performance monitoring, is usually a product category, a vendor's dashboard for latency, throughput, and errors in one application. Observability is the broader capability those tools help deliver. Many APM products now run on the same logs, metrics, and traces, so in practice the two overlap heavily.
It depends on how much instrumentation exists and how many services are involved. Adding structured logging and basic tracing to a handful of services, or building it into a new service from day one, takes a few sprints. Retrofitting a large microservices estate that's been running for years is much bigger. You have to decide what to trace across dozens of services, set retention that fits the budget, and tune sampling, all without disrupting production traffic. It goes faster when it has its own timeline instead of competing with feature work.
Keep exploring
System integration: patterns, methods, and when you need it
A plain-language reference on system integration, covering what it means, the four patterns teams actually use, how to pick one, and the failure modes that make integration projects overrun.
6 min readEngineeringWhat is multi-tenant architecture? Single vs multi-tenant
Pool, schema-per-tenant or database-per-tenant? How each tenancy model trades isolation for cost, where shared-schema designs leak data, and why most SaaS teams start pooled and move only their largest or most regulated customers to a silo.
6 min readEngineeringWhat is alphanumeric: character sets, validation, and encoding
Alphanumeric means letters plus digits and nothing else. See the 62 ASCII characters, Unicode letter and number classes, regex patterns for JavaScript and Python, EBCDIC pitfalls, and where an alphanumeric allow-list helps security.
6 min read