# Digma’s DCA Engine

Unlike traditional observability tools focused on alerting to problems in retrospect, Digma leverages a Dynamic Code Analysis (DCA) engine that identifies issues at the code level in pre-prod environments, allowing teams to prevent them earlier.

### Continuous over Manual

The DCA engine identifies issues automatically, as the developer works, and does not rely on manual processes.

### Insights over raw data

Raw observability data takes too much effort to translate into something practical. The DCA engine processes the raw data to reveal critical actionable insights.

### Focus on code

Traditional APMs focus on the infrastructure and APIs, whereas the DCA engine focuses on code-level issues and patterns.

[Play](https://youtu.be/3wgQl69WSvw?vq=hd1440)

[See Our Documentation](https://docs.digma.ai/digma-developer-guide)

## The Dynamic Code Analysis engine

Digma’s Dynamic Code Analysis (DCA) engine introduces an advanced approach to observability by proactively identifying potential issues before they materialize in production.

It achieves this by analyzing observability tracing data, even when data volumes are low. Leveraging pattern matching and anomaly detection techniques, Digma’s algorithm extrapolates expected application performance metrics, enabling it to detect deviations or potential problems that have not yet impacted the application. In analyzing the tracing data, Digma pinpoints the issue to the specific responsible code and commits.

### How to identify code issues with Dynamic Code Analysis

We’ve curated a list of blog posts about concepts and practices. We also published an Udemy course which you can access below.

[Take Course](https://www.udemy.com/course/continuous-feedback/learn/lecture/39593948?couponCode=D02F9269A24524BEBEF1#overview)

## The state of the shift left

Insights from 280 engineers and managers on their shift-left progress, ability to catch issues early, troubleshoot quickly and minimize wasted engineering time.

## Frequently Asked Questions

### How is Digma different from traditional observability tools?

Most observability tools focus on monitoring production environments, meaning you only find out about issues after they impact users. Digma works at the code level in pre-production, inside your IDE, identifying issues before they appear in production. This means fewer rollbacks, less rework, and a smoother development process.

### Can Digma help with breaking changes across the team’s codebase?

Yes! Digma detects which areas of the code and components are affected by each change or pull request, ensuring no one accidentally introduces breaking changes. This reduces the risk of regressions and disruptions, helping the team move faster with confidence.

### How does Digma improve performance and scalability without adding overhead?

Unlike traditional performance monitoring tools that require heavy instrumentation, Digma analyzes lightweight tracing data and identifies inefficient code patterns before they hit production. This means your team gets actionable insights on slow execution paths, scalability bottlenecks, and inefficient queries—without impacting development speed.

### Does Digma require changes to our code or infrastructure?

No. Digma runs locally and does not require code modifications, manual profiling, or additional observability setup. It’s OTEL-compliant, so it fits right into your existing observability stack without adding friction.

### How can my team start using Digma?

Getting started is easy—just install the Digma plugin, and it immediately starts analyzing your code in real-time. Want to learn more? Check out our documentation, blog, or Udemy course to see how Digma can fit into your team’s workflow.

### How does Digma help my team prevent last-minute firefighting?

Digma proactively identifies breaking changes, performance regressions, and scalability issues while your team is still developing. Instead of reacting to production incidents, your engineers can address problems earlier—saving debugging time, reducing deployment risks, and keeping the team focused on delivering features.