LaunchDarkly + New Relic: Accelerating safe releases with Intelligent Observability

How does a modern engineering organization manage rapid continuous delivery while maintaining high system stability and minimizing operational risk?

For high-velocity software teams, that means moving beyond static pre-commit checks and deploying runtime feature management directly alongside real-time telemetry. Engineering teams face high developer toil and increased mean time to resolution (MTTR) when triaging production incidents across complex microservice architectures. At the same time, massive code volume from AI agents has created downstream bottlenecks in deployment pipelines and PR reviews, shifting the engineering focus from writing code to safely controlling runtime exposure. 

In our October New Relic Now fireside chat, Brian Emerson, Chief Product Officer at New Relic, and Jonathan Nolen, Chief Product Officer at LaunchDarkly, shared how combining runtime feature toggles with neutral, real-time telemetry transforms software delivery into a resilient, automated operational workflow.

Here’s what they uncovered.

Key takeaways

• Move beyond IDEs: Generative AI and automated coding assistants increase code volume exponentially, turning code review and deployment into critical delivery bottlenecks. Safe release velocity requires runtime controls, not just static checks
• Close and automate your feedback loop: Linking New Relic telemetry directly to LaunchDarkly feature flags creates a 4-step closed feedback loop (release, observe, evaluate, act), turning passive monitoring into automated containment that slashes blast radius duration from hours to minutes
• Enrich traces with OpenTelemetry: Standardizing telemetry through OpenTelemetry (OTel) allows engineering teams to inject feature flag context directly into distributed traces, eliminating blind spots during complex production rollouts

The velocity dilemma and the software factory

The introduction of AI-powered development tools has radically altered the software supply chain. Developers are writing and generating code faster than ever before. However, speeding up code creation inside the IDE creates downstream friction at the deployment and verification stages.

As software production operates more like an automated factory, traditional manual review processes and long pull request queues fail to scale. When volume increases without automated runtime safeguards, engineers face a stark choice: slow down releases or accept unmanaged risk in production. Decoupling code deployment from user release via feature management allows organizations to push code continuously while controlling exact exposure levels at runtime.

Connecting LaunchDarkly Feature Control with New Relic telemetry

Achieving high-velocity releases requires a clear division of operational responsibilities between feature management platforms and telemetry engines:

• LaunchDarkly as the runtime control plane: Functions as the runtime execution engine (spanning CodeControl and AgentControl), dynamically configuring software behavior, managing targeted rollouts, and serving as the primary kill switch during anomalies
• New Relic as the neutral telemetry engine: Provides comprehensive, unbiased observability across system performance, error rates, latency metrics, and user behavior signals without vendor bias

By integrating these systems via OTel standards, flag attributes are attached directly to transaction traces. When an anomaly occurs, telemetry immediately isolates whether a specific feature flag state caused the regression.

Closing the loop: From progressive rollout to automated containment

Modern continuous delivery relies on a closed-loop operational workflow with four distinct phases:

1. Release: Software changes are deployed to production with feature flags turned off or limited to a tiny user percentage (e.g., 1%)
2. Observe: New Relic ingests real-time metrics, logs, and distributed traces tagged with corresponding flag identifiers
3. Evaluate: Automated guardrail policies continuously evaluate incoming telemetry against predefined error budgets and performance baselines
4. Act: If metrics breach acceptable safety thresholds, automated trigger actions immediately alert LaunchDarkly to roll back or disable the offending flag instantly

This closed-loop automation helps eliminate manual triage delay, potentially reducing incident duration, and shrinking blast radius from hours of customer impact to seconds of automated mitigation.

Engineering guidance and scaling safely

During the fireside discussion, Jonathan Nolen outlined practical recommendations for engineering leaders, platform teams, and SREs looking to scale progressive delivery safely:

• Start small with high-impact services: Begin implementing feature flags and automated guardrails on core tier-1 microservices where deployment anxiety is highest
• Enrich distributed traces early: Ensure feature flag metadata is injected into OpenTelemetry trace headers to streamline root-cause analysis across complex distributed architectures
• Establish clear guardrail baselines: Define explicit performance thresholds and error metrics beforehand so automated rollback triggers operate without manual intervention ambiguity

What’s next and how you can learn more

The integration of LaunchDarkly and New Relic delivers the safety net modern development teams require to match the velocity demands of AI-driven software creation. By pairing dynamic runtime controls with neutral telemetry, engineering organizations can innovate rapidly without sacrificing system reliability.

New Relic and LaunchDarkly are actively seeking design partners across Python, OpenTelemetry, Go, and Java ecosystems to refine automated release guardrails. To learn more about optimizing your release pipeline, join our limited preview here.