I have spent enough time around enterprise observability initiatives to recognize a familiar pattern: the project starts with good intentions, an impressive dashboard gets built, monitoring agents are deployed everywhere, and suddenly the organization has more telemetry than it knows what to do with.
At first, everyone is excited. There are charts. There are colorful service maps. There are CPU and memory metrics, transaction data, traces, logs, container events, API calls, database queries and probably the temperature of a server rack somewhere. Teams can pull up a screen and see a living, breathing representation of the business systems they run.
Then an application goes down.
And nobody can explain why.
That is the uncomfortable truth: many observability implementations have become another version of the enterprise data swamp. We collect massive amounts of information, store it at significant expense, build dashboards around it, and still struggle to identify the root cause when something important breaks.
More data is not the same thing as more insight. In fact, in many cases, more data makes the problem worse.
The mistake: Treating collection as observability
Observability is supposed to help us understand what is happening inside complex systems by looking at their external signals. That is a useful goal, especially now that most enterprises are running highly distributed systems across public clouds, private infrastructure, SaaS platforms, APIs, containers and legacy applications that refuse to retire gracefully.
The mistake is assuming that observability means collecting everything.
It does not.
I have seen organizations ingest every log line, every event, every trace and every metric because they can. The tools encourage it. The vendors often encourage it. And engineers, understandably, worry that the one piece of data they decide not to collect will be the piece they need at 2:00 a.m. during a production outage.
So they keep it all.
The outcome is predictable: enormous telemetry volumes, rising platform costs, slow searches, alert fatigue and dashboards that look great during a demonstration but are rarely used during an actual incident. The operations center becomes a wall of screens that people glance at without really seeing.
That is not observability. That is data accumulation.
The goal should not be to know everything about every system at every second. The goal is to know enough of the right things to detect meaningful problems, understand their business impact, isolate likely causes, and take action quickly.
That requires design. It requires discipline. And it requires accepting that not every piece of telemetry has equal value.
If no one knows what to do when an alert fires, it is not an alert. It is noise delivered with urgency.

Why noise wins
The core problem is noise. Enterprise systems produce a tremendous amount of it, and cloud-native architectures multiply the issue. A simple customer transaction might touch a web application, an API gateway, identity services, multiple microservices, several data stores, a message queue, an external payment provider and a SaaS application. Each layer generates its own logs, traces, metrics, and events.
When something goes wrong, teams are often buried under thousands or millions of signals. A latency spike in one service triggers warnings in dependent services. Auto-scaling creates transient infrastructure events. Retries fill the logs. A minor configuration change produces dozens of alerts. Suddenly, everyone is staring at the observability platform, trying to determine whether the original failure was a database issue, a network issue, a deployment issue, an API issue or simply a downstream symptom.
Too many organizations respond by creating more alerts.
That is almost always the wrong answer.
An alert should represent an actionable condition. If no one knows what to do when an alert fires, it is not an alert. It is noise delivered with urgency. If an alert fires constantly, gets ignored and does not lead to a meaningful investigation, it is training people to disregard the observability system precisely when they need it most.
I have watched teams normalize alert storms because they happen so often. They learn to wait for someone to complain, or for a major outage to occur, before digging into the data. At that point, the expensive observability platform has become a passive archive rather than an operational advantage.
Before adding another dashboard
More telemetry won't necessarily improve observability. CIOs and IT operations teams should be able to answer five questions:
1. What are we protecting? Identify the business services and processes that matter most.
2. What indicates a problem? Define the signals that reveal performance or availability issues.
3. What caused it? Capture enough context to trace failures across systems and dependencies.
4. Who needs to act? Make sure alerts have clear owners and actionable next steps.
5. What data is worth keeping? Set collection, sampling and retention policies based on operational value.
Start with business outcomes, not telemetry
The best observability programs begin with an obvious but often overlooked question: what are we trying to protect?
Not “What can this tool collect?” Not “Which dashboard should we build?” The first question should be: which business capabilities matter most?
For an online retailer, that may be product search, checkout, payment authorization, inventory accuracy and order confirmation. For a bank, it may be customer authentication, funds transfer, fraud detection and transaction settlement. For a healthcare organization, it may be patient access, claims processing, scheduling and clinical-system availability.
Once you identify those critical capabilities, work backward.
What user experience signals indicate success or failure? What application-level measures show whether the capability is working? What dependencies are most likely to affect it? What technical signals would help engineers distinguish between a localized issue and a widespread failure?
This is where observability starts becoming useful. You are connecting system behavior to business value.
A CPU chart can be useful. So can a memory metric. But neither one matters much if it is not tied to a question someone needs answered. Is checkout slowing down? Are customers receiving errors? Is a particular region affected? Did a deployment introduce the problem? Is one dependency creating a bottleneck across the system?
Those are the questions that matter during an incident. Design your telemetry around answering them.
Make signals intentional
Enterprises need to establish standards for what gets collected, how long it is retained, who owns it and why it exists. This may sound bureaucratic, but it is exactly what prevents an observability program from becoming a dumping ground.
Metrics should focus on service health, performance, capacity and business-level outcomes. Logs should be structured and searchable, not an endless stream of inconsistent text. Tracing should follow important transactions across service boundaries, especially where complex dependencies exist. Events should be meaningful changes in system state, not every minor occurrence that happens to be technically detectable.
The point is to collect meaningful information that helps teams act, not simply more information.
I would also encourage teams to make sampling a normal part of their strategy. Not every transaction needs a full trace retained forever. Not every debug-level message belongs in a long-term production log archive. Organizations should capture detailed telemetry for high-value transactions, unusual behavior, failures, security-relevant events and systems under active investigation.
Everything else can be sampled, aggregated or retained for a shorter period.
This is not cutting corners. It is recognizing that a system designed to collect everything eventually becomes less useful to the people trying to operate it.
Observability should make complex systems easier to understand. If it is making them harder to understand, it is time to drain the swamp.

Observability must lead to action
The final measure of an observability program is simple: does it help people make better decisions faster?
If an engineer gets an alert, can they understand the impact? Can they identify the likely source? Can they see which dependency changed? Can they correlate the technical issue with the customer or business process affected? Can they take a clear next step?
If the answer is no, the organization does not have an observability problem because it lacks data. It has an observability problem because its data has not been organized into operational intelligence.
The winners will not be the enterprises with the most dashboards or the largest telemetry bills. They will be the ones that reduce noise, focus on critical business capabilities, standardize meaningful signals and build incident workflows around fast, confident action.
Observability should make complex systems easier to understand. If it is making them harder to understand, it is time to drain the swamp.
David Linthicum is a globally recognized thought leader, innovator and influencer in AI, cloud computing and cybersecurity. He has more than 30 years of experience in enterprise technology and, until early 2024, served as managing director and chief cloud strategy officer at Deloitte Consulting LLP.