What is observability and why does it matter for Salesforce DevOps?

In the world of Salesforce development, we’re constantly striving for smoother releases, more stable applications, and a better experience for our users. A key practice that underpins all of these goals, and one that's becoming increasingly vital in Salesforce DevOps, is observability. In this blog post, DevOps Architect Andy Barrick deep dives into what observability is, and why should it be on your radar if you’re serious about optimizing your Salesforce DevOps lifecycle.

Making sense of observability: more than just monitoring

At its core, the goal of observability is to allow you to explore your application’s health easily and understand what’s happening inside your Salesforce orgs, especially when things aren’t behaving as expected.

Think of it like a car’s dashboard. Your dashboard provides a real-time status of various critical elements: your speed, fuel level, engine temperature, and so on. It also has warning lights that illuminate when something needs your attention – perhaps low oil pressure or an engine issue. Without this clear, immediate feedback, you’d be driving blind, only realizing there’s a problem when it’s potentially too late or more serious.

Observability provides that dashboard for your Salesforce orgs and applications. It’s about instrumenting your systems so they produce a rich stream of data (often referred to as telemetry data — typically logs, metrics, and traces) that you can then use to ask questions and get answers about their state, performance, and behavior.

Observability is more than just traditional monitoring, which often focuses on pre-defined health checks. Observability allows for deeper, more exploratory investigation when novel problems arise — those “unknown unknowns.”

Why observability is a natural partner for Salesforce DevOps

DevOps, at its heart, is about breaking down silos, increasing collaboration, and delivering value faster and more reliably. Observability fits perfectly into this philosophy.

One of the core tenets of DevOps is the idea of “shifting left” — catching and addressing issues as early as possible in the development lifecycle. Just as with coding, it’s far less expensive and disruptive to identify and fix a problem in development or testing than it is once it has reached production and impacted your users. Good observability practices give your team the insights needed to spot these potential issues — from performance degradation in a new feature to an integration behaving unexpectedly — much earlier in your release pipeline.

Effective CI/CD pipelines, a cornerstone of Salesforce DevOps, also benefit immensely. Observability can provide crucial feedback at each stage, helping you understand the impact of changes and catch regressions before they escalate.

When you’re practicing DevOps, you should inherently be reducing the instances where costly failures occur in production because issues are being identified and resolved much earlier. Observability is a critical enabler of this proactive approach to secure DevOps.

The unique challenges of observability in Salesforce

While the principles of observability are universal, the Salesforce platform has its own unique characteristics and challenges when it comes to gaining visibility.

Governor limits

This is one of the main ways Salesforce applications can “break” or underperform. Exceeding limits on CPU time, SOQL queries, heap size, or DML statements will bring critical processes to a halt. While Salesforce does provide some visibility into org-level limits (like storage usage and API calls), this information isn’t always consolidated and can be tricky to review proactively. Some teams consider splitting their Salesforce org as a solution to this challenge. While that can be a valid option in certain cases, it’s often worth exploring whether improvements can be made by refining your existing logic first. Starting there is typically best practice — and may help you avoid the complexity of an org split altogether.

Transaction-level blind spots

Crucially, transaction-level governor limits are only surfaced in debug logs, which cannot always be running — they too are subject to their own limits. So although a “close to limit” message will exist in the debug log, you still may not become aware you’re approaching a limit when a transaction actually fails. This reactive approach is far from ideal.

Disparate information and error handling

When errors do occur, Salesforce’s standard functionality (like sending error emails) doesn’t always ensure the right people get the right information as quickly as possible to remediate. Solutions focused on better Flow error monitoring or centralized logging aim to close this gap between failure and fix, which is a key aspect of observability.

That’s exactly where tools like Gearset’s Flow and Apex error monitoring come in. Instead of relying on error emails landing in the right inbox — or worse, waiting for users to flag issues — Gearset provides a centralized, real-time view of Flow and Apex failures across your org. Error monitoring capabilites like these are a straightforward way to tighten up feedback loops, spot issues before they snowball, and keep your team focused on delivering value.

Complexity of modern orgs

With increasing use of declarative automation, Apex, Lightning Web Components, AppExchange packages, and integrations, understanding the end-to-end flow and pinpointing the root cause of an issue can be incredibly complex without the right observational tools and techniques.

Flow and Apex errors are notoriously tricky to catch and diagnose. For practical advice on leveraging the concept of observability to catch issues early, join the upcoming Gearset webinar, “Catch Flow and Apex errors fast: A guide to proactive Salesforce monitoring”.

What does good Salesforce observability look like?

Achieving good observability in a Salesforce context means being able to:

• Proactively monitor critical user journeys and business processes.
• Quickly identify and diagnose performance bottlenecks across Apex, Lightning Components, and integrations.
• Understand resource consumption and stay ahead of governor limit issues.
• Trace errors back to their root cause efficiently, reducing Mean Time To Detection (MTTD) and Mean Time To Resolution (MTTR).
• Gain insights from logs, metrics, and traces in a centralized and queryable way.
• Set up intelligent alerting that notifies the right teams about meaningful issues, not just noise.

For instance, imagine a scenario where users report that saving a complex Opportunity record is sometimes very slow. With good observability, you could dive into traces for those specific transactions, analyze relevant metrics for CPU time and SOQL queries, and examine logs to pinpoint exactly which piece of custom Apex, Flow, or even a poorly optimized third-party component is causing the delay.

The path forward: embracing observability

Observability is an essential part of the Salesforce DevOps lifecycle, not an afterthought or add-on. It’s an ongoing process of surfacing insights that feed into planning and prioritization.

These insights improve the quality of builds, reduce the need for reactive firefighting, and help teams deploy at speed without losing control.

For Salesforce teams looking to scale their DevOps practices, improve release quality, and ensure their applications perform optimally, embracing observability is no longer a luxury — it’s a necessity. It helps your team build with confidence, knowing they have the tools to understand and address issues swiftly, ultimately leading to more robust applications and happier stakeholders.

Kickstart your observability strategy

If you’re ready to go deeper and learn how to implement these observability principles to proactively manage your org’s health, reduce troubleshooting time, and build more resilient applications, then I encourage you to check out Gearset’s Salesforce observability whitepaper.

And if you’re looking to build your own expertise or upskill your team, the free Salesforce observability course on DevOps Launchpad is a great resource. You’ll learn how to optimize your Salesforce org stability and performance — and earn a certificate along the way! Learn more about the course here.