The observability contract is up for renewal and the question is back on the agenda: Dynatrace vs Datadog (or Datadog vs Dynatrace, depending on who asks), which one serves the SRE team better? Both platforms cover APM, infrastructure, logs, Kubernetes and user experience. In a demo, they look very much alike.
The risk is deciding on a gut feeling or on a feature checklist. What matters to an on-call team is measured differently: time to find the cause of an incident, effort to instrument a new service, how readable the bill is, how good the SLOs are.
The goal of this article: provide a set of verifiable criteria and an OpenTelemetry proof of concept that sends exactly the same data to both platforms, so you compare on evidence. This blog is mostly about Dynatrace, so we have taken care to stay factual, source every point and quote no prices. On the Dynatrace side, the comparison targets Dynatrace SaaS; remarks on Managed are flagged.
Dynatrace vs Datadog: the fundamental differences
The two tools follow different, publicly documented approaches. Summarising them honestly helps frame the right test hypotheses.
| Criterion | Dynatrace | Datadog |
|---|---|---|
| Collection | OneAgent (automatic instrumentation) and Dynatrace Operator on Kubernetes; native OTLP ingest | Datadog Agent, deployed on Kubernetes with Helm or the Datadog Operator; OTLP ingest in the Agent |
| Correlation | Topology model (Smartscape) and the Davis root cause engine | Correlation through unified tags (service, env, version) and analysis features in each product |
| Query language | DQL on Grail storage | Search and query languages specific to each product (metrics, logs, traces) |
| Commercial model | A single commitment drawn down per capability (DPS) | Per-product pricing, each with its own units; see the official pricing page |
| Hosting | SaaS, or Managed (self-hosted) for sovereignty constraints | SaaS, with several regions (“sites”) to choose from |
For prices, refer to the official pages and the quotes you receive: they depend on volume and contract, and change often. For a similar comparison method, see the comparison of SLOs in Dynatrace, Grafana and Prometheus.
Proof of concept prerequisites
- A trial environment on each platform (a Dynatrace SaaS tenant, a Datadog organisation in the region you need).
- A test Kubernetes cluster with a demo application instrumented with OpenTelemetry.
- An OpenTelemetry Collector (contrib distribution or the Dynatrace one), as in deploying the Collector on Kubernetes.
- A Dynatrace API token with the OTLP ingest scopes (
openTelemetryTrace.ingest,metrics.ingest,logs.ingest) and a Datadog API key for the Agent.
Step 1: send the same data to both platforms
The comparison is only worth something if the input data is identical. The Collector therefore duplicates each pipeline to two exporters: the Dynatrace OTLP endpoint and the OTLP receiver of the Datadog Agent running in the cluster.
receivers:
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
http:
endpoint: 0.0.0.0:4318
processors:
batch: {}
exporters:
otlphttp/dynatrace:
endpoint: https://${env:DT_ENV_ID}.live.dynatrace.com/api/v2/otlp
headers:
Authorization: "Api-Token ${env:DT_API_TOKEN}"
otlp/datadog:
endpoint: datadog-agent.datadog.svc.cluster.local:4317
tls:
insecure: true
service:
pipelines:
traces:
receivers: [otlp]
processors: [batch]
exporters: [otlphttp/dynatrace, otlp/datadog]
metrics:
receivers: [otlp]
processors: [batch]
exporters: [otlphttp/dynatrace, otlp/datadog]
logs:
receivers: [otlp]
processors: [batch]
exporters: [otlphttp/dynatrace, otlp/datadog]
Critical lines: the Authorization header must start with Api-Token followed by a space; on Managed, the URL becomes https://<domain>/e/<env-id>/api/v2/otlp. The tls.insecure setting is only acceptable for traffic inside the cluster.
On the Datadog side, enable OTLP ingest in the Agent, for example with these documented environment variables:
DD_OTLP_CONFIG_RECEIVER_PROTOCOLS_GRPC_ENDPOINT=0.0.0.0:4317
DD_OTLP_CONFIG_RECEIVER_PROTOCOLS_HTTP_ENDPOINT=0.0.0.0:4318
DD_OTLP_CONFIG_LOGS_ENABLED=true
Then also install each tool’s native agent (Dynatrace Operator, Datadog Agent with its integrations) on part of the nodes: automatic instrumentation is part of what you are evaluating.
Step 2: define measurable criteria
Score each platform from 1 to 5 on quantified criteria, with the supporting evidence (screenshot, query, timed duration):
- Time to diagnosis: inject three faults (slow dependency, OOMKilled pod, HTTP 500 after a deployment) and time how long it takes to reach the cause, by someone who does not know the scenario.
- Instrumentation effort: number of steps and configuration lines for a new service to appear with correlated traces, metrics and logs.
- SLOs: time to create an availability SLO and a burn rate alert for that service, as described in burn rate alerts.
- Queries: write the same question (“the ten slowest endpoints, by version”) in DQL and in the Datadog query languages, and rate readability.
- Predictable cost: being able to estimate next month’s bill from the usage screens.
- Constraints: hosting region, sovereignty, self-hosting requirements (only Dynatrace offers a Managed option).
Step 3: run the Datadog vs Dynatrace failure scenarios
An example of a simple, reversible fault: lower a pod’s memory limit until it is OOMKilled.
kubectl -n demo set resources deployment/checkout --limits=memory=64Mi
kubectl -n demo get pods -w
# return to the initial state
kubectl -n demo rollout undo deployment/checkout
In Dynatrace, check whether a problem is opened and which cause it suggests; in Datadog, whether a monitor fires and how many clicks it takes to reach the Kubernetes event. Also note the noise: how many alerts for a single fault.
How to check it works
- On the Dynatrace side, the DQL query
fetch spans | filter service.name == "checkout" | summarize count()returns a volume comparable to what Datadog shows over the same period. - On the Datadog side, the
checkoutservice appears in the APM catalogue with its traces. - The Collector logs show no export errors (
kubectl logs deploy/otel-collector | grep -i error). - Volume differences stay small; if not, check sampling on each side before comparing.
Good practices
- Fix the scorecard before the proof of concept and get it signed off: you avoid picking criteria that confirm a preference.
- Have on-call engineers run the tests, not only the platform team.
- Keep OpenTelemetry as the foundation: instrumentation stays portable whatever the final choice.
- Ask for written quotes on the same forecast volume, and date them.
- Write a blameless report: what worked, what got stuck, without naming a “loser”.
Frequently asked questions
Which is cheaper, Dynatrace or Datadog?
There is no general answer: the two pricing models do not use the same units, and the outcome depends on your volumes. Compare two written quotes on the same scope and project them over three years.
Can we keep both tools?
Technically yes, thanks to the Collector duplicating the flows, but it doubles the operational effort and often the bill. It is reasonable during a transition, rarely as a target.
What if we need self-hosting?
Dynatrace Managed lets you host the platform in your own data centre; Datadog is offered as SaaS. If sovereignty is a hard requirement, it settles the question before anything else.
Conclusion
Dynatrace and Datadog are both mature platforms; the right choice depends on your context, not on a general ranking. A proof of concept fed by the same Collector, injected faults and a measurable scorecard give you a decision you can defend to the team and to management alike.
span.observer is an independent community blog, not affiliated with Dynatrace LLC or Datadog, Inc. Dynatrace and Datadog are trademarks of their respective owners. Features and offers change: check them in each vendor’s official documentation (Dynatrace, Datadog).