LaunchDarkly Standardized on New Relic. Here's Why It Matters.

When a company like LaunchDarkly makes a deliberate, public decision about which observability platform they trust to run on, I pay attention because LaunchDarkly understands this domain better than almost any organization in the market. Their own product depends on the quality of their observability. Their choice reflects something real about what engineering teams need right now.

Who LaunchDarkly Is, and Why Their Choice is Telling

LaunchDarkly runs the control plane for software releases at some of the world's most demanding engineering organizations. Their platform processes tens of trillions of feature flag evaluations every day, for thousands of customers who depend on it to ship software safely and at scale. If something were to go wrong in LaunchDarkly's own infrastructure, the consequences could be immediate and visible. Their internal "source of truth" for system health has to be unquestionable. 

For several years, LaunchDarkly has used a variety of observability tools to monitor that infrastructure. Recently, they decided to standardize their primary observability and telemetry workloads on New Relic.

Their CTO, Cameron Etezadi, has published the reasoning for doing so and it is worth reading.

Bigger Than One Customer Win

LaunchDarkly is not a typical enterprise customer. They are a category leader in feature management and runtime control, with deep expertise in the domain where observability matters most: high-velocity software delivery. When an engineering organization of that sophistication and scale evaluates the observability market and makes a deliberate choice, engineering leaders should pay attention to why.

Their reasoning comes down to a principle at the core of New Relic’s engineering philosophy. Observability works best when it is neutral. As AI accelerates the pace of software development and deployment, engineering teams are producing and shipping code faster than ever. The last thing a team needs in that environment is an observability layer that has its own stake in the features being evaluated.

LaunchDarkly put it plainly. A provider who bundles feature management and monitoring into a single black box platform cannot be an unbiased judge of feature performance. As agentic AI moves from experimentation into production, the tolerance for “good enough” observability is shrinking. Teams are shipping more code, more frequently, with less human review of each individual change. In this environment, the quality and neutrality of your telemetry is critical. That is what New Relic is built for. Intelligent Observability, full stop. 

At New Relic, we see this across the industry. Engineering teams come to us after years of trying to get actionable signal out of platforms built to do too many things. The observability data is there, but it is filtered through layers of competing priorities. When your monitoring vendor also sells the tools your engineers are evaluating, the data is never fully yours. The decision to move to New Relic is a confirmation of something we have believed since we started building this company.

What It Means for Our Shared Customers

LaunchDarkly and New Relic share a significant base of customers today. These are engineering organizations that rely on both platforms as part of how they build and run software. For those teams, this is a signal about the direction of their own stack.

The combination of LaunchDarkly and New Relic addresses something that has become increasingly important in the AI era: The gap between knowing something went wrong and knowing what change caused it. New Relic tells you what is happening across your stack. LaunchDarkly gives you the controls to respond safely, incrementally, in real time. Together, we close a loop that neither platform closes alone.

LaunchDarkly's internal migration to New Relic is the first step in a longer arc of work we are doing together. We are committed to making that integration deeper and more seamless for the teams who depend on both.

What Comes Next

As Cameron put it in his post, this is the beginning of that story, and what comes next is a deeper technical integration connecting New Relic's observability signals directly to LaunchDarkly's release controls. 

At New Relic NOW, Cameron joined us to talk through what drove that decision and what it means for the teams innovating on both platforms. We will share more as this work progresses.

We are glad to be the platform LaunchDarkly trusts. And we are excited about what we are building together.