Who should set up and implement Observability: Developers or DevOps Engineers?
The question of whether implementing observability should be the responsibility of developers, DevOps engineers, or SRE engineers has sparked a long-running debate in the industry. While tools and platforms often fall under the domain of infrastructure teams, gaining visibility into your system requires strong collaboration.
The definitive answer is that observability is always a collective effort. Neither developers nor DevOps engineers can implement a complete observability solution independently. Instead, successful observability relies on two primary and interconnected efforts: Instrumentation and Implementation.
The Observability Debate: Why Collaboration is Essential
Observability is defined as having the ability to understand the internal state of your system, which includes your application, infrastructure, and networking. It helps answer not only what the state of the system is (e.g., CPU utilization or failed requests) but also why it is in that state and how to fix the issues. This requires integrating the three core pillars: metrics, logs, and traces.
For a system to achieve this level of feedback, the collective roles must ensure these pillars are fully captured and processed.
1. The Developer’s Crucial Role: Instrumentation
The initial responsibility for establishing observability lies firmly with the developers of the application. This critical phase is known as instrumentation.
Mandatory Instrumentation Tasks:
Developers are responsible for ensuring the application instruments the necessary data points along with the infrastructure and networking. These include:
- Instrumenting Metrics: The application must be set up to ”throw some metrics”. Metrics provide historical data of events, helping to identify when CPU utilization, memory usage, or HTTP requests peaked or failed over time.
- Instrumenting Logs: Developers must actively write various types of logs, including info logs, debug logs, error logs, and any other relevant logs. Proper logging enables teams to understand application behavior better, pinpointing the exact part or package of the application that was affected during an event or failure.
- Implementing Traces: Developers should implement traces, which provide extensive information to debug, troubleshoot, and fix issues. Traces allow for complete request tracing, showing how a request passed through components like the load balancer, front-end, back-end, and database, and how much time was spent in each stage.
The Instrumentation Necessity
If developers neglect to instrument or implement these metrics, logs, or traces, tools used by the infrastructure team will have no data to consume or analyze, rendering them ineffective.
A Note on Auto-Instrumentation
While manual instrumentation remains critical for fine-grained visibility, many modern observability tools now support auto-instrumentation. This approach automatically collects key metrics, logs, and traces without requiring extensive developer effort. Auto-instrumentation removes much of the manual, error-prone work developers would otherwise need to do to ensure complete observability, helping teams achieve faster and more consistent coverage across services.
2. The DevOps/SRE Role: Implementation and Setup
Once the developers properly instrument the application, the DevOps Engineers and SREs step in to handle the implementation part. Their responsibility is to build and manage the underlying infrastructure and platforms that consume, process, and present the data.
Key Implementation Tasks:
- Setting up the Monitoring Stack: This involves setting up tools like Splunk, which look for the metrics that the developers instrumented.
- Setting up the Logging Stack: This involves building and configuring the systems that collect, process, and visualize application logs, ensuring that all log data is centralized, searchable, and available for real-time analysis.
- Setting up Distributed Tracing: Establishing the platforms that consume and manage the tracing data.
- Deployment and Configuration: Ensuring the instrumented applications are deployed, often on platforms like a Kubernetes cluster, so that the data can be successfully fed to the observability platforms.
Summary: A Complete Feedback System
Observability only provides value when the developers and DevOps/SREs work together. The developers feed the necessary information into the platform, and the DevOps/SRE team provides the platform infrastructure.
This collective effort ensures that the system provides complete feedback about its internal state, allowing end-users (including developers, QE, or management) to look at the platforms (like the logging stack or monitoring stack) to query specific errors and ensure that critical objectives, such as service level agreements (SLAs), are continuously met.
How WeAre Can Help
WeAre is a technology company focusing on observability. Our services support technology teams to manage business-critical digital services with confidence. Our Observability as a Service (OaaS) offering provides real-time insights across your entire technology stack, ensuring systems remain reliable, optimized, and resilient. By proactively preventing problems, we help you focus on your business goals without compromising performance.
You can learn more about our Observability as a service (OaaS) from here, and let us show you how observability can help you run resilient businesses that are built for real-world success.