Given your constraints:

• 120 engineers
• ~$80k/month Datadog spend (~$960k/year)
• Need logs + metrics + traces in one platform
• Everything runs in AWS
• Comfortable self-hosting in your own VPC

...you're exactly the kind of company where self-hosting can make financial sense. Many organizations at your scale move from per-GB/per-host SaaS pricing to paying primarily for EC2, storage, and engineering time.

The strongest candidates

Platform	Self-hosted	Logs	Metrics	Traces/APM	Datadog replacement?	Typical cost reduction
SigNoz	✅	✅	✅	✅	Closest	70–95%
Grafana OSS Stack (Grafana + Mimir + Loki + Tempo)	✅	✅	✅	✅	Yes	70–95%
Uptrace	✅	✅	✅	✅	Good	70–90%
HyperDX	✅	✅	✅	✅	Emerging	60–90%
Elastic Stack	✅	✅	✅	✅	Yes	40–80%

---

1. SigNoz (probably the closest Datadog replacement)

This is usually the first recommendation for companies leaving Datadog because it was designed specifically as a unified, OpenTelemetry-native observability platform. It provides logs, metrics, traces, dashboards, service maps, alerts, and trace-to-log correlation in a single interface backed by ClickHouse. devhelm.io

Pros

• One UI
• Native OpenTelemetry
• Excellent trace/log correlation
• Service dependency maps
• Built-in dashboards
• Alerting
• ClickHouse performs well with high-cardinality telemetry

Cons

• You now operate ClickHouse
• Not as polished as Datadog
• Smaller ecosystem

Infrastructure

Typical production deployment:

• Kubernetes
• ClickHouse cluster
• OpenTelemetry Collectors
• S3 for long retention

For a company your size this is very manageable.

Expected savings

If Datadog is:

• $80k/month

You might spend approximately:

• $5–15k/month AWS infrastructure
• plus engineering time

Many teams report reductions on the order of 70–90%+ after moving from Datadog to self-hosted OpenTelemetry stacks. devhelm.iouptrace.devagentdeals.dev

---

2. Grafana OSS Stack (my favorite for mature platform teams)

Components:

• Grafana
• Loki (logs)
• Tempo (traces)
• Mimir (metrics)
• Prometheus
• OpenTelemetry Collector

This has become the "standard" cloud-native self-hosted stack.

Pros

Very scalable.

Used by:

• large SaaS companies
• fintechs
• cloud providers
• gaming companies

Huge ecosystem.

Very flexible.

Excellent AWS support.

Can store:

• logs in S3
• traces in S3
• metrics in object storage

Storage becomes dramatically cheaper than Datadog.

Cons

It's several systems rather than one integrated product. You're responsible for deployment, upgrades, and tuning across the components. cubeapm.com

---

3. Uptrace

Uptrace is another OpenTelemetry-native platform using ClickHouse.

Good if you primarily care about:

• APM
• traces
• metrics
• log correlation

Less ecosystem than Grafana.

Simpler than the Grafana stack.

Lower operational burden.

Pros

• Fast
• Small footprint
• ClickHouse backend
• Easy migration from OTel

Cons

• Smaller community
• Fewer integrations

Organizations already standardized on OpenTelemetry often report significant cost reductions compared with Datadog due to ClickHouse-backed storage and avoiding proprietary ingestion pricing. uptrace.dev

---

4. HyperDX

Interesting newer option.

Built around:

• OpenTelemetry
• ClickHouse

Includes:

• logs
• traces
• metrics
• session replay

If your product is customer-facing SaaS, session replay can be valuable.

Still less mature than SigNoz or Grafana. agentdeals.dev

---

5. Elastic

Elastic can absolutely replace Datadog.

You'll get:

• logs
• metrics
• traces
• search
• dashboards
• alerting

Pros:

• Incredible search
• Excellent log analytics

Cons:

• Expensive infrastructure
• Elasticsearch tuning
• JVM operational overhead

Many teams moving away from Datadog avoid swapping one expensive operational footprint for another, unless they already run Elastic extensively.

---

What I'd recommend for your environment

Because you have 120 engineers, I'd narrow it to two realistic options.

Option A — SigNoz

Choose this if you want:

• Datadog-like experience
• One UI
• Easier migration
• Less platform engineering

Architecture:

Applications
      │
OpenTelemetry SDKs
      │
OTel Collectors
      │
SigNoz
      │
ClickHouse
      │
S3 (retention)

---

Option B — Grafana OSS

Choose this if your platform team is comfortable owning infrastructure.

Applications

↓

OTel Collectors

↓

Tempo
Loki
Mimir

↓

Grafana

This stack gives maximum flexibility and scales extremely well, but requires more operational expertise.

---

Migration strategy I'd recommend

Rather than replacing Datadog overnight:

1. Standardize all services on OpenTelemetry instrumentation.
2. Deploy OpenTelemetry Collectors in AWS.
3. Mirror telemetry to both Datadog and the new backend during a validation period.
4. Validate dashboards, alerts, and SLOs.
5. Move lower-priority services first.
6. Reduce Datadog ingestion and retention as confidence grows.
7. Eventually retire Datadog or keep only a minimal footprint for specialized use cases.

Using OpenTelemetry as the instrumentation layer also keeps you from being tied to any single backend in the future.

For an $80k/month Datadog bill

If I were advising your leadership, I'd rank the options like this:

1. SigNoz — best balance of features, unified experience, and operational simplicity.
2. Grafana OSS (Grafana + Loki + Tempo + Mimir) — most scalable and flexible, but with higher operational complexity.
3. Uptrace — excellent if APM is the primary focus and you want a lighter-weight platform.
4. HyperDX — promising, especially if frontend session replay is important.
5. Elastic — strong technically, but generally not my first choice for reducing both cost and operational overhead.

At nearly $1M/year in Datadog spend, even after accounting for AWS infrastructure and the engineering effort to operate a self-hosted platform, it's plausible to reduce annual observability costs by hundreds of thousands of dollars while retaining unified logs, metrics, and traces—provided you're willing to own the observability infrastructure and optimize telemetry volume and retention.

For an engineering organization of ~120 people spending $80k/month ($960k/year) on Datadog, the biggest savings usually come from moving to an OpenTelemetry-based stack and controlling your own storage/retention rather than swapping one SaaS APM vendor for another.

The main candidates I would evaluate:

PlatformSelf-hosted?Logs + Metrics + TracesLikely cost impact vs DatadogOperational burdenSigNozYes✅ UnifiedVery high savings potentialMediumGrafana LGTM StackYes✅ Unified (assembled)Highest possible savingsHighElastic ObservabilityYes✅ UnifiedHigh savings possibleMedium-highOpenSearch + OpenTelemetryYesMostly yesHigh savings, especially logsMedium-highJaeger + Prometheus stackYesPartialVery low costHigh (multiple tools)

1. Best Datadog replacement: SigNoz

SigNoz is probably the closest architectural replacement for Datadog for your situation. It is built around OpenTelemetry and provides a single UI for logs, metrics, traces, dashboards, alerts, and APM-style workflows. It can be deployed in your own infrastructure/VPC. SigNoz (+1 more citation)

Why it fits a 120-engineer SaaS company:

• One product instead of assembling five systems

• Native OpenTelemetry ingestion

• Trace → log → metric correlation

• Service-level APM views

• Lower storage costs using ClickHouse-backed architecture

• Easier migration path from Datadog agents/instrumentation SigNoz

A realistic architecture:

Applications | OpenTelemetry SDKs | OpenTelemetry Collector | SigNoz | ClickHouse + object storage

Rough cost model:

• Datadog: ~$960k/year

• Self-hosted SigNoz:

EC2/EKS compute

• ClickHouse storage

• S3 retention

• engineering ownership

Depending on ingestion volume and retention, many companies in your range land somewhere in the $10k–$30k/month infrastructure + operational cost range, potentially saving hundreds of thousands annually. Exact savings depend heavily on your current GB/day ingestion.

2. Maximum savings: Grafana LGTM stack

The most cost-efficient option is usually:

• Grafana — dashboards/UI

• Loki — logs

• Tempo — traces

• Mimir — metrics

This is often called the LGTM stack. It is entirely self-hostable and works well with OpenTelemetry. YouTube

Advantages:

• Lowest vendor cost

• Excellent Kubernetes/AWS ecosystem fit

• Huge community

• Storage can be optimized aggressively with S3

Tradeoffs:

• You operate multiple distributed systems

• More tuning:

cardinality control

• retention policies

• compaction

• scaling

• upgrades

For a platform team that already runs Kubernetes/EKS, this is very viable.

A typical architecture:

Services | OpenTelemetry Collector / Grafana Alloy | +--> Loki (logs) +--> Mimir (metrics) +--> Tempo (traces) | Grafana

This can potentially reduce your observability bill by 80–95%, but you are effectively becoming your own observability vendor.

3. Elastic Observability

Elastic is another mature self-managed option. Its APM supports OpenTelemetry data and correlates application performance data with logs and metrics. elastic.co

Good fit if:

• Your company already uses Elasticsearch

• Logs are the largest part of your Datadog bill

• Search experience is a priority

Potential downside:

• Elasticsearch-scale clusters can become expensive if logs are high volume.

• More operational complexity than SigNoz.

4. OpenSearch-based stack

Because you are AWS-based, also consider:

• OpenSearch for logs/search

• OpenTelemetry Collector

• Prometheus-compatible metrics

• Jaeger or Tempo for traces

This is attractive if your biggest Datadog cost driver is log ingestion and retention.

What I would do in your position

For a 120-engineer SaaS company, I would run a short bake-off:

Phase 1 — Measure current Datadog usage

Break the $80k/month into:

• Logs ingestion %

• Metrics custom metrics %

• APM hosts/traces %

• Retention/storage

• Synthetic monitoring/RUM/etc.

The migration target depends heavily on this.

Phase 2 — Pilot two stacks

Run both for 30 days:

Pilot A: SigNoz

• Fastest Datadog replacement

• Lowest migration friction

Pilot B: Grafana LGTM

• Benchmark lowest achievable cost

Send identical OpenTelemetry data to both.

Measure:

• Query latency

• Engineer adoption

• Alert quality

• Storage cost per TB

• Operational hours/week

Likely outcome

For your size, I would expect:

• SigNoz: best balance of savings + usability

• Grafana LGTM: cheapest at scale if your platform team is willing to own it

• Elastic: best if logs/search dominate

• OpenSearch: best AWS-native cost play for log-heavy environments

A realistic goal would be reducing $80k/month to somewhere around $10k–$25k/month total cost while keeping unified logs, metrics, and traces—provided you standardize on OpenTelemetry and aggressively manage retention/cardinality. SigNoz (+1 more citation)

For a 120-engineer company, I would not attempt a “lift and shift” of every