Dynatrace helps you answer these questions by extending AI observability for a new wave of coding agents, including Claude Code, Google Gemini CLI, OpenAI Codex CLI, OpenCode, and GitHub Copilot SDK. Together, these integrations give engineering leaders, platform teams, and developers a consistent way to understand agent activity, token consumption, costs, tool behavior, and runtime impact: without forcing teams to stitch together fragmented telemetry across terminals, SDKs, dashboards, and development workflows. Dynatrace public AI agent instrumentation examples on GitHub demonstrate how to provide industry leading observability that drives performance, cost efficiency, and governance across complex, distributed AI-driven systems—all through a unified Dynatrace platform experience that developers can access directly via MCP without leaving their IDE.

From agent activity to engineering insight

As organizations adopt multiple coding agents, new adoption challenges emerge. One team might use Claude Code in the terminal, another may build internal tools with GitHub Copilot SDK, while others experiment with Gemini CLI or Codex CLI. Platform teams want visibility into usage, availability, and costs. Engineering leaders want to know whether agents improve delivery. Security and governance teams want confidence that all prompts, tool usage, and actions can be monitored appropriately.

Dynatrace provides a practical answer to these challenges: a single observability layer for agile development workflows. For agents that emit OpenTelemetry directly, such as Claude Code, Gemini CLI, and Codex CLI, Dynatrace can ingest telemetry related to sessions, tokens, costs, tool executions, errors, and performance. For GitHub Copilot workflows, Dynatrace adds production context, software delivery automation, and GitHub-based integrations that connect agent activity to real engineering workflows.

The payoff is clear. Developers gain visibility into how agents behave in real work. Platform teams can track adoption, usage trends, and cost signals. Engineering leaders can correlate agent activity with commits, pull requests, and delivery outcomes. And with an MCP-enabled production context, teams can connect coding-agent actions to what is happening in production.

“Before we instrumented Claude Code, we had no easy way to break down how our engineers actually used AI, which models, for what tasks, and at what cost. Now we can pinpoint inefficient model use and guide usage toward better cost-performance tradeoffs.”
— Markus Heimbach, Senior Director Software Development

Multiple coding agent experiences, one observability strategy

Each coding agent has a different operating model, which is why a common observability layer matters.

Claude Code

Claude Code already supports built-in OpenTelemetry, making it easy to send metrics and logs to Dynatrace with no code changes. Teams can track sessions, tokens, costs, tool activity, API health, and engineering output such as commits and pull requests. Logs, dashboards, and alerts help teams investigate failures, spot latency spikes, and catch unusual spend or error patterns early.

Gemini CLI

Gemini CLI includes OpenTelemetry-based observability and preconfigured dashboards, making it a strong fit for Dynatrace AI observability. Teams can correlate agent activity with broader platform signals and move quickly from raw telemetry to action. This includes debugging failed runs, identifying slow or error-prone tool calls, and alerting on cost or reliability regressions.

Codex CLI

Codex CLI supports opt-in OpenTelemetry monitoring, giving teams a path to audit usage and strengthen governance across CLI, IDE, and app experiences. With Dynatrace, logs and traces help investigate request flows, delays, and failures across agent workflows. Alerts can flag degraded reliability, unexpected behavior, or rising token consumption before they become larger issues.

GitHub Copilot SDK

GitHub Copilot SDK lets teams embed agentic workflows directly into applications, while Dynatrace adds live observability and security context. This matters because embedded agents become part of real engineering and production-adjacent workflows. Dynatrace helps trace execution paths, use logs for debugging and auditability, and set alerts for failures, latency, or policy-relevant events.

OpenCode

OpenCode is a terminal-based AI coding agent that helps developers work through coding tasks directly from the command line. Because OpenCode ships with native OpenTelemetry support, teams can route telemetry to Dynatrace without code changes by setting standard OTLP environment variables. With Dynatrace, teams can track LLM call volume, session activity, tool usage, request latency, and workflow behavior across real developer sessions. Traces help teams inspect LLM requests, tool executions, session lifecycle events, message processing, file snapshots, or diff operations.

Across all operating models, the value is the same: one strategy for monitoring adoption and impact, understanding costs, logging and tracing agent activity, alerting on reliability issues, and debugging real-world workflows as coding agents scale across the enterprise.

Why this matters now

Teams are no longer asking whether coding agents are useful. They’re asking how to drive adoption, scale them safely, govern them consistently, and prove their impact. That requires visibility into usage, cost, reliability, and engineering outcomes across teams and tools. Dynatrace helps organizations make that shift with the observability and production context needed to expand coding-agent adoption with confidence.

The coding-agent market is moving fast. Claude Code, GitHub Copilot SDK, Google Gemini CLI, and OpenAI Codex CLI each represent a different path toward agentic software delivery, from terminal-based workflows to embedded SDKs and governed local execution. At the same time, Dynatrace has been expanding its developer-facing AI surface with the Dynatrace MCP Server, GitHub Copilot integrations, and AI observability capabilities built to connect agent behavior with real production systems. The timing matters because teams are no longer evaluating whether coding agents are useful. They’re deciding how to drive adoption, scale up usage safely, govern usage consistently, and measure real impact.

Ready to see AI coding agents through a Dynatrace lens?

With Dynatrace, teams can understand adoption, spend, reliability, tool behavior, and engineering outcomes in one place, while giving agents access to the live production context they need to make better decisions.

Whether your developers are working in Claude Code, building on GitHub Copilot SDK, experimenting with Gemini CLI, or adopting Codex CLI, Dynatrace helps bring observability, governance, and production awareness into the heart of agentic software delivery.

Public examples already demonstrate this approach for Claude Code, and the broader Dynatrace MCP and AI observability ecosystem provides the foundation to extend the same value across the next generation of coding agents.

Ready to learn more?

In our Git repository, you’ll find step-by-step examples for supported coding-agent workflows, including how to configure OpenTelemetry export, send telemetry data to Dynatrace, and use the provided dashboards to analyze the activity of your AI coding agents.

The post Dynatrace expands AI Coding Agent monitoring for Claude Code, Google Gemini CLI, Codex CLI, OpenCode, and GitHub Copilot SDK appeared first on Dynatrace news.

The Dynatrace platform provides expanded data access via the Dynatrace MCP server and several APIs that tie into agentic integrations from our ecosystem, our IDE plugins, CLIs, and Dynatrace® Apps. The Dynatrace MCP server has been a cornerstone of making this innovation available to our developer audience right in the IDE. However, MCP is heavily relying on text-based output. This blog introduces new Dynatrace MCP Server application support, which we’re happy to contribute to the community, upgrading UI capabilities by enabling data visualization. It empowers developers and organizations to build their own agentic platforms and visualize experience data, without relying solely on LLM reasoning.

Why are MCP applications so valuable to Developers?

A picture is worth a thousand words

Charts, color cues, and visual tables are here for a reason. We just need a quick look to determine whether something is right or wrong, and with MCP Apps, those visuals can appear in the same conversation with Dynatrace Assist or when interacting with Dynatrace Intelligence from within Kiro, GitHub Copilot, or any other MCP integration, where we ask questions while avoiding context switching and speeding up analysis and result checking. Once we get the insights we need, we can dive even further into the platform applications with comprehensive context.

For example, during a problem investigation, we observe a spike in requests across all endpoints, especially for the v1/trade/long/process endpoint.

Dynamic visual results

Interactive UIs let users modify results per their needs. With the new visual results, we can filter, pivot, and drill into results without re-issuing prompts; the model and UI remain in sync and continue the conversation with a richer context.

Actionability built in

Visuals can include action buttons, for example, Open in Notebooks, which calls back to the server to drill into the data stored in Dynatrace Grail® unified data lakehouse. You can create dashboards and notebooks directly from any page without changing context.

Human verification

Human involvement in data analysis is one of the factors that differentiate these processes from purely LLM-based solutions. Keeping humans in the loop to validate and interpret results visually is one of the most important factors for organizations that want to maintain control over their data analysis process.

MCP App architecture

MCP extension protocol integration

The Dynatrace MCP Server uses the @modelcontextprotocol/ext-apps library to register interactive UI applications alongside traditional text-based tool responses. This allows the MCP client (such as GitHub Copilot) to extend the standard MCP results with visual capabilities.

Tool-to-UI binding

Tools are registered via the _meta.ui.resourceUri property that links the tool’s output to its visual counterpart. When execute_dql returns results, the host knows to render the associated UI app as well.

Data flow

Structured output parsing

The tool returns results as structured markdown containing metadata and a JSON block. The UI app parses this response, extracting record counts, warnings, and the actual data records.

Real-time client-side rendering

A lightweight TypeScript-based web-app (execute-dql.ts) receives the tool result via the app.ontoolresult callback and dynamically builds an interactive HTML table—complete with sortable columns, hover states, and expandable JSON cells.

Single-file bundling

When using Vite with vite-plugin-singlefile, the HTML, CSS, and TypeScript are bundled into a self-contained HTML resource that the MCP server serves on demand.

See it in action

Take a look at this example video showing an investigation into slowdowns.

In the following screenshots, you can see examples of how data that is structured in a visual way helps us to ask the right questions or continue investigations promptly.

In reviewing error logs, we see frequent errors appearing in easytrade-broker-service.

While analyzing service degradation due to the slowdown, we found that two services were affected for approximately 30 minutes.

What about security?

Let’s call out the elephant in the room: security is a major concern with MCP servers, and adding HTML rendering on top is likely to raise eyebrows.

There are a couple of security measures and best practices in place to protect our users:

1. Dynatrace MCP Apps are always rendered in a sandboxed iframe controlled by the host.
2. Our MCP apps communicate only with the MCP host via JSON RPC. No direct communication with the internet occurs with Dynatrace MCP apps.
3. We make use of battle-tested React components, inheriting all security-relevant features of React.

Get started

Dynatrace MCP Apps is already included in the latest version of our local MCP Server, and will soon be added to our remote server as well. If you’re already using the local MCP server, you only need the updated version, which should be automatically available in your Dynatrace environment. If the update doesn’t happen automatically, or if you aren’t already using the local Dynatrace MCP server, install it via the GitHub MCP registry and start experimenting using the provided quickstart.

To better understand how you can uplevel your AI assistants with live production insights from Dynatrace, read our most recent blog post or explore the Dynatrace Agentic AI ecosystem in Dynatrace Hub.

The post Fueling visual insights with MCP applications for complex data analysis appeared first on Dynatrace news.

With Dynatrace, developers can rest assured that everything they need—from development to deployed infrastructure—is available with full context at every touchpoint. Traditionally, developers have had limited visibility into production systems, relying on operations teams to surface issues after deployment. This disjointed approach often leads to delays in identifying and resolving problems, increased risk of production failures, and inefficiencies in the development process

With GitHub’s recent announcement of custom agents, Dynatrace is proud to launch its first custom agent, introducing a powerful new entry point for Dynatrace insights directly within GitHub repositories, where developers can act on them immediately. This integration ensures that developers no longer need to leave their familiar GitHub environment to access critical observability and security data. Whether it’s triaging production errors, validating deployments, or responding to security vulnerabilities

This isn’t just another way to consume observability and security insights from Dynatrace—this is about achieving true end-to-end visibility, from code to production, by combining the capabilities of Dynatrace with GitHub Copilot and its custom agents.

In this blog post, we’ll explore the most prominent use cases offered by this integration and demonstrate how deploying these two tools in tandem can unlock new levels of efficiency, reliability, and security for your software development lifecycle.

How it works

Dynatrace and Git solutions support opposite ends of the Software Delivery Lifecycle: Git hosts your code repository while Dynatrace monitors your production infrastructure. Agentic AI and the MCP protocol allow bridging of this gap, essentially allowing AI assistants to verify their code in production.

Setting up the connection with Dynatrace is simple

We recommend using your local MCP server for prototyping and testing things out. First, follow these instructions to create a platform token with the necessary scopes. Once this is done, install the MCP server in your GitHub repository: you’ll find the configuration in Settings > CoPilot > Coding Agent (an example can be found in the repository linked above).

Finally, you need to set up the custom agent in your repository under .github/agents/Dynatrace.md. For your convenience, we’ve provided an example file that you can simply drag and drop. Update your MCP server’s credentials, and you’re all set.

Tip: Before promotion to production, we recommend switching from your local MCP Server to our remote MCP Server.

Use cases: Unlock the power of production insights

Dynatrace’s custom agent for GitHub Copilot unlocks the following core use cases, each designed to enhance developer productivity and ensure operational excellence:

Incident Response and Root Cause Analysis

Developers can investigate and resolve production failures directly within GitHub by leveraging Dynatrace Davis® AI for real-time problem detection, backend stack trace analysis, and business impact assessment. This provides higher precision in less time, without requiring changes to workflows at other locations.

Deployment impact analysis

The agent validates deployments by comparing pre- and post-deployment metrics, detecting anomalies, and providing data-driven health assessments to ensure smooth rollouts.

Production error triage

Dynatrace systematically monitors and categorizes production errors. Now, with a custom agent, we can prioritize remediation efforts, reduce error backlogs, and improve application reliability directly in GitHub Copilot.

Performance regression detection

Dynatrace continuously monitors application performance baselines, ensuring that any degradation in latency, throughput, or error rates is flagged before it impacts your end-users or breaches service-level objectives (SLOs).

Release validation and health checks

Acting as an automated quality gate, the agent can validate releases, monitor post-deployment stabilization, and ensure compliance with SLOs.

Security vulnerability response and compliance monitoring

Dynatrace integrates security workflows into GitHub, proactively identifying vulnerabilities, mapping them to compliance frameworks, and providing prioritized remediation recommendations

To infinity and beyond

Dynatrace’s custom agent is more than just a tool for many use cases—it’s a powerful toolkit that helps you unlock the full potential of your existing data to uncover the insights you need, precisely when you need them. The use cases we’ve highlighted here are just the beginning. The true power of this integration lies in the dynamic nature of AI, enabling you to search, query, and connect insights across a vast network of agents and platforms. While the journey may take you through uncharted territories of interconnected ecosystems, and it may sound a bit scary at first, there is huge value (and fun!) in turning complexity into clarity and productivity.

Ready to consolidate observability and get answers faster?

Have you already seen the recently launched GitHub custom agents, and are you interested in trying out Dynatrace’s custom agents? Then familiarize yourself with our remote MCP Server and learn how to integrate it into your development landscape.

The post From code to cloud: Dynatrace launches first GitHub custom agent, consolidating observability for developers appeared first on Dynatrace news.

As software systems grow increasingly complex, developers need powerful tools that can seamlessly integrate various platforms and services. Amazon Q Developer CLI has revolutionized AI-assisted development by bringing intelligent code assistance directly to your terminal. Now you can use Model Context Protocol (MCP) to bring real-time observability data directly from Dynatrace into your workflow,

Whether you’re a developer, DevOps engineer, or SRE, this integration will help you make more informed decisions faster. Through simple natural language queries, you can monitor application performance and access logs, identify issues, and automate common observability tasks across both AWS and Dynatrace platforms, without leaving the terminal or your IDE of choice.

Let’s dive in and see how you can leverage the full potential of Amazon Q Developer CLI and Dynatrace MCP server in your development process. Read on to learn how to:

1. Configure Amazon Q Developer CLI to work with MCP servers.
2. Set up the Dynatrace MCP server for real-time observability data.
3. Use natural language queries to monitor and troubleshoot applications across both AWS and Dynatrace platforms.

Breaking down the Amazon Q Developer CLI integration

Setting up this integration typically takes 15 to 30 minutes, with no additional AWS infrastructure required beyond an existing Amazon Q Developer CLI setup.

The architecture diagram below illustrates how MCP enables seamless integration between local development environments and AWS cloud services through Amazon Q Developer CLI. Through standardized MCP communication, a developer can use multiple operating systems to interact with Dynatrace observability tools and AWS offerings.

Before you begin

To complete the walkthrough, teams must first meet the following prerequisites:

• Install Amazon Q Developer CLI.
• Configure AWS CLI with the appropriate credentials (an Amazon Builder account or enterprise license is required).
• Have a Dynatrace account or get a free 15-day trial.
• Have or create a Dynatrace OAuth Client. For the needed scopes, see the Dynatrace MCP readme.

Walking through the Amazon Q Developer CLI installation process

MCP configuration in Amazon Q Developer CLI is managed through JSON files. The interface supports two levels of MCP configuration:

• Global configuration: ~/.aws/amazonq/mcp.json – Applies to all workspaces
• Workspace configuration: .amazonq/mcp.json – Specific to the current workspace

AWS MCP server setup

Once the Amazon Q Developer CLI is installed, configure it to use AWS MCP Server.

1. Open a terminal, and create the following file:
   vi ~/.aws/amazonq/mcp.json
2. Paste the following configuration into the file:

{ 
  "mcpServers": { 
    "awslabs.core-mcp-server": { 
      "command": "uvx", 
      "args": [ 
        "awslabs.core-mcp-server@latest" 
      ], 
      "env": { 
        "FASTMCP_LOG_LEVEL": "ERROR" 
      }, 
      "autoApprove": [], 
      "disabled": false 
    } 
  } 
}

Dynatrace MCP server setup

Add the configuration for the Dynatrace MCP server to mcp.json. Navigate to the Environment Variable section to set up the environment variables for Dynatrace with the needed OAuth Client Scopes. Extending our example from above, the MCP configuration file would look like this:

{ 
  "mcpServers": { 
"awslabs.core-mcp-server": { 
      "command": "uvx", 
      "args": [ 
        "awslabs.core-mcp-server@latest" 
      ], 
      "env": { 
        "FASTMCP_LOG_LEVEL": "ERROR" 
      }, 
      "autoApprove": [], 
      "disabled": false 
    }, 
    "dynatrace-mcp": { 
      "command": "npx", 
      "args": ["-y", "@dynatrace-oss/dynatrace-mcp-server@latest"], 
      "env": { 
        "OAUTH_CLIENT_ID": "", 
        "OAUTH_CLIENT_SECRET": "", 
        "DT_ENVIRONMENT": "" 
      } 
    } 
  } 
}

Verify the MCP server integration with Amazon Q Developer CLI

After configuring both AWS and Dynatrace MCP servers, verify that the integration is working properly. Run the command “q chat” in the terminal to start an interactive session with Amazon Q Developer CLI.

$ q chat 
 
To learn more about MCP safety, see https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-mcp-security.html 
✓ dynatrace_mcp loaded in 3.48 s 
✓ 1 of 1 mcp servers initialized 
 
Welcome to  
 
 █████╗ ███╗  ███╗ █████╗ ███████╗ ██████╗ ███╗  ██╗  ██████╗  
██╔══██╗████╗ ████║██╔══██╗╚══███╔╝██╔═══██╗████╗ ██║ ██╔═══██╗ 
███████║██╔████╔██║███████║ ███╔╝ ██║  ██║██╔██╗ ██║ ██║  ██║ 
██╔══██║██║╚██╔╝██║██╔══██║ ███╔╝ ██║  ██║██║╚██╗██║ ██║▄▄ ██║ 
██║ ██║██║ ╚═╝ ██║██║ ██║███████╗╚██████╔╝██║ ╚████║ ╚██████╔╝ 
╚═╝ ╚═╝╚═╝  ╚═╝╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝ ╚═══╝  ╚══▀▀═╝  
 
╭───────────────────────── Did you know? ─────────────────────────╮ 
│ │ 
│ /usage shows you a visual breakdown of your current  │ 
│ context window usage │ 
│ │ 
╰─────────────────────────────────────────────────────────────────╯ 
 
/help all commands • ctrl + j new lines • ctrl + k fuzzy search 
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The CLI is now connected to both AWS and Dynatrace MCP servers, allowing you to inquire about functionality across both AWS and Dynatrace platforms.

Testing AWS connectivity

Here are some questions you can ask q chat to verify and the expected result (note they may not be the same for everyone).

Tip: Amazon Q supports just typing “/mcp” or “/tools” and it will show you which servers are available and which tools it can call at a glance.

> Are you connected to AWS?
 
Yes, I am connected to AWS. I can help you interact with AWS services through the AWS CLI. I can make AWS API calls using the use_aws tool, which allows me to perform operations like: 
 
• Describing EC2 instances 
• Listing S3 buckets 
• Managing IAM users and roles 
• Working with other AWS services like Lambda, DynamoDB, etc.
 
Is there a specific AWS task or service you'd like me to help you with? I can run AWS CLI commands on your behalf to retrieve information or make changes to your AWS resources.
 
> Are you connected to Dynatrace?
 
Yes, I am connected to Dynatrace through the Dynatrace MCP integration. I have access to several Dynatrace-specific tools that allow me to: 
 
• Get logs for monitored entities 
• Retrieve entity details 
• List and get details about vulnerabilities 
• Execute and verify DQL (Dynatrace Query Language) statements 
• Send Slack messages via Dynatrace's Slack connector 
• Get ownership information for entities 
• View and manage problem details 
• Work with Kubernetes events 
• Create notification workflows 
 
Would you like me to perform any specific Dynatrace-related tasks for you? For example, I could get information about the connected Dynatrace environment, list current problems, or help you with DQL  
queries.

Now, we’re connected to both AWS and Dynatrace MCP servers, which means you can look at various AWS- and Dynatrace-related tasks, such as checking resources, identifying problems, getting logs, and more. Here are some sample prompts below:

Infrastructure monitoring

"Show me all EC2 instances that have high CPU usage in the last hour and correlate this with Dynatrace performance metrics" 
"List any auto-scaling events from AWS and check if they match performance degradation patterns in Dynatrace"

Application performance

"Compare the response times of our Lambda functions between AWS CloudWatch and Dynatrace monitoring" 
"Show me the slowest API Gateway endpoints and their corresponding service flows in Dynatrace"

Security analysis

"Find all security groups with open ports and cross-reference with Dynatrace security vulnerabilities" 
"Check SSL certificate expiration dates across our AWS resources and validate them against Dynatrace security monitoring"

Log analysis

"Find all error patterns in CloudWatch logs and match them with problem patterns detected by Dynatrace" 
"Show me application errors that appear in both AWS logs and Dynatrace problem detection"

Cost management

"Generate a report comparing our AWS resource costs with their performance metrics from Dynatrace" 
"Identify underutilized AWS services based on both CloudWatch and Dynatrace usage patterns"

If you want to avoid unwanted server activations and unnecessary charges during development, you can clean up with the following:

Open a terminal and navigate to the following file. Remove the MCP configurations you added as part of this setup and save them. This will ensure both AWS and Dynatrace MCP servers are not loaded when you start “q chat”.

vi ~/.aws/amazonq/mcp.json

AI-assisted development is now a reality

The integration of Dynatrace MCP with Amazon Q Developer CLI marks a significant advancement in AI-assisted development. By providing standardized access to external tools and data sources, developers can work with their production environment much more efficiently and with context-awareness. Whether you’re working on remediating problems, database optimization, code analysis, or full stack development, the combination of Amazon Q Developer CLI and Dynatrace MCP offers a powerful platform for modern development and DevOps practices.

Follow the stories: Scaling AI-assisted development with Dynatrace MCP

As the integration of AI tools like Amazon Q Developer CLI and Dynatrace MCP evolves, developers and organizations can expect even greater capabilities to streamline workflows and enhance observability. These advancements not only allow real-time insights but also empower teams to make informed decisions faster, with minimal overhead.

Interested in learning more about how Dynatrace can help you in your AI-assisted development? Check out these resources:

• Part 1 of our agentic AI series introduces MCP, A2A, and the future of automation.
• Part 2 of this agentic AI series explores how monitoring A2A and MCP communications results in better, more effective agentic AI.
• Part 3 of this series covers AI agent observability and monitoring, and how to scale and monitor Amazon Bedrock Agents.
• Full-stack observability for AI with NVIDIA Blackwell and NVIDIA NIM is covered in part 4 of this series.
• Check out Dynatrace MCP and the Dynatrace AI Observability solution for AI agent monitoring and MCP monitoring at scale.

The post Enhance your development workflow with the Amazon Q Developer CLI for Dynatrace MCP appeared first on Dynatrace news.

Developers deploy on production systems at lightning speed every day. Site Reliability Engineers (SREs) strive to maintain production stability yet face an impossible trade-off: hamper releases with rigid security policies or risk shipping software riddled with vulnerabilities. Dynatrace Runtime Vulnerability Analytics and Security Posture Management flips this dynamic by giving SREs real-time visibility into exposed vulnerabilities and misconfigurations in production, allowing them to prioritize and remediate threats more quickly. This blog explores how an observability-driven approach puts SREs in control of security, compliance, and uptime—without sacrificing delivery velocity.

Software teams outpace security

Modern software teams have embraced agile development practices, DevOps, and continuous integration/continuous deployment (CI/CD) pipelines. While this speeds up innovation and value delivery to the end customer, it also floods production environments with frequent code changes and new infrastructure—often outpacing the ability to fully verify security compliance before deployment.

Challenges for the modern SRE

Oftentimes, organizations try to address this challenge by rolling out security tools throughout the entire software development lifecycle (SDLC), making sure no unscanned code makes it into production.

However, a couple of challenges arise with this setup, which leave SREs in a position of balancing a difficult tradeoff:

• Mission-critical role. SREs are accountable for system stability, ensuring users and businesses aren’t affected by downtime or compromised data.
• Conflicting pressures. SREs want to enforce a “zero vulnerabilities in production” policy. However, developers need to ship product features quickly to remain competitive – a difficult decision when SDLC tools find thousands of vulnerabilities.
• Lack of visibility. For SREs to gain insight into their vulnerability risks, they have to painstakingly pull together multiple data sources from their development teams. However, those only represent a point in time when the scan happened. In other words, they are blind to real-time risk and don’t have visibility into what is actually exposed in production.
• Exposure to zero-day vulnerabilities. Every week, approximately 700 new CVEs get published – a nightmare for any SRE who is responsible for the security of production systems. With the frequent turnover of deployments and complex microservice architectures, it’s impossible to maintain an overview of which deployed assets are vulnerable and need attention.
• Mounting anxiety. To enable fast-value creation with digital products, SREs are forced to allow vulnerabilities to make it into production. Without real-time insights into which they are exposed and where they reside, pinpointing the truly critical issues can feel like guesswork.

This friction leads to watered-down policies, sleepless nights, and a constant sense that there is a gap in the defense—right where it matters most: in production.

Closing the gap

Dynatrace Runtime Vulnerability Analytics and Security Posture Management bridges exactly this gap between continuous delivery speed and SREs’ need for operational security. Rather than relying solely on static scans or best-effort CI/CD or exposure checks, it brings risks caused by vulnerabilities and misconfigurations into clear focus while applications and infrastructure are actually running.

Key attributes of a robust runtime vulnerability analytics solution: 

• Production-centric insights. Identifies which vulnerabilities are actively exposed and which are connected to critical data assets, enabling SREs to prioritize real threats and reduce noise. 
• Observability at scale. Works alongside an observability platform that tracks infrastructure, application performance, and security events in real time. 
• Automated detection. Identifies exposed vulnerabilities or configuration drifts the moment they appear in production. (Learn more about Dynatrace Workflow Automations.) 
• Integrated with DevOps workflows. Serves as a seamless layer in the existing CI/CD pipeline, ensuring it doesn’t obstruct the pace of innovation. (Learn more about security integrations.) 

Securing production environments with Dynatrace

How can customers secure their production environments with Dynatrace security products?

In many proof-of-concept (POC) scenarios, development teams are overwhelmed by long, unprioritized lists of vulnerabilities and alerts. Manually triaging, assigning, and resolving these issues slows down delivery and often leads to weakened security admission policies—just to keep value flowing to customers.

Dynatrace helps cut through the noise by empowering SREs to focus on what truly matters. Here’s how:

• Vulnerabilities App (Runtime Vulnerability Analytics)
  Eliminate endless lists of vulnerabilities. Instead, leverage intelligent prioritization that highlights critical exposures based on real-time observability context—so SREs and developers can focus on what’s actually exploitable in production.
• Security Posture Management
  Continuously monitor your live production environments for misconfigurations and policy violations. This enables your systems to stay compliant and secure without manual checks or guesswork.
• Contextual Insights & Remediation Guidance (Code-Level Vulnerabilities)
  Go beyond surface-level alerts. Dynatrace pinpoints the exact library or code snippet responsible for a vulnerability, enabling developers to fix issues quickly and accurately—no more hunting through codebases.
• Continuous Feedback Loop (Automations, Workflows, and Integrations)
  Share real-time vulnerability data across development and product teams. This capability fosters a culture of secure coding and supports security becoming a shared responsibility— not a bottleneck.

Looking ahead

Dynatrace continues to evolve its security capabilities to meet the growing demands of modern production environments. Our roadmap includes deeper integrations with incident management platforms, expanded support for SDLC security tools, and enhanced AI-driven threat intelligence.

We’re also investing in more out-of-the-box workflow automations to streamline vulnerability detection and remediation—reducing manual effort and accelerating response times.

Our mission remains clear: to empower Site Reliability Engineers with end-to-end visibility and control, from code creation to live production. With Dynatrace, SREs can focus on strengthening system resilience, confident that security risks won’t silently undermine operational stability.

By tapping into real-time, production-focused insights, Site Reliability Engineers can align reliability and agility under one cohesive framework—and truly rest easier knowing that vulnerabilities won’t stay hidden for long.

Continue reading to learn more about how Dynatrace is empowering SREs to improve availability, performance, and user experience and solve problems proactively with full-stack visibility and real-time insights.

The post Empowering SREs with runtime vulnerability analytics and security posture management appeared first on Dynatrace news.