For a mid-market SaaS company already standardized on OpenTelemetry (OTel) and paying roughly $60k/month (~$720k/year) for observability, the biggest lever is usually not just license cost — it is avoiding a rebuild of your telemetry pipeline and minimizing operational burden.

The good news: several self-hosted platforms now accept OTLP directly and provide logs + metrics + traces in a unified experience. SigNoz (+1 more citation)

A practical shortlist for your profile:

PlatformOTel-native?LogsMetricsTracesOperational complexityLikely TCO profileSigNozYes — built around OpenTelemetry✅✅✅MediumLowGrafana LGTM Stack (Grafana + Loki + Tempo + Mimir)Yes✅✅✅HighLowest infra cost, higher engineering costUptraceYes✅✅✅Medium-lowLowHyperDX / ClickStackYes✅✅✅MediumLow-mediumElastic ObservabilityYes✅✅✅Medium-highMedium-high

SigNoz (+2 more citation)

1. SigNoz — closest "Datadog/New Relic replacement" pattern

SigNoz is probably the closest fit if your goal is:

• keep OTel instrumentation unchanged

• send OTLP telemetry

• get APM + logs + metrics in one UI

• avoid assembling multiple OSS projects

SigNoz is OpenTelemetry-native and supports logs, metrics, traces, exceptions, dashboards, and alerts. Self-hosted deployments accept OTLP directly through the OpenTelemetry Collector. SigNoz (+1 more citation)

Architecture:

Services | OpenTelemetry SDK | OTel Collector | SigNoz | ClickHouse

TCO estimate (rough order of magnitude)

For a SaaS company currently spending $60k/month:

Cost areaEstimateInfrastructure$3k-$15k/monthPlatform engineering ownership0.25-1 FTEVendor license$0Total~$5k-$25k/month

The biggest unknown is telemetry volume:

• logs/day

• trace sampling rate

• retention period

• metric cardinality

A team emitting 5 TB/day of logs has a very different economics profile than one emitting 200 GB/day.

Best fit: You want "replace Datadog/New Relic with OSS, but keep the workflow."

2. Grafana LGTM — lowest software cost, highest platform responsibility

The Grafana ecosystem is the most mature OSS observability stack:

• Grafana → visualization

• Loki → logs

• Tempo → traces

• Mimir → metrics

Grafana's stack works well with OpenTelemetry, but it is more of a composable platform than a single APM product. SigNoz

Typical architecture:

Applications | OTel Collector | +--> Mimir (metrics) | +--> Loki (logs) |

Given your context:

• $60k/month current spend (~$720k/year)
• Strong internal platform/SRE capability
• Already standardized on OpenTelemetry
• Looking for unified logs + metrics + traces rather than assembling multiple products

you're in the sweet spot where self-hosting can make economic sense. The biggest question isn't licensing—most of the leading options are free or inexpensive—but operational complexity versus engineering time.

Shortlist

1. SigNoz

This is probably the closest thing today to a self-hosted Datadog/New Relic replacement.

Strengths

• Built around OpenTelemetry from the beginning
• Native OTLP ingestion
• Unified traces, metrics, logs
• ClickHouse backend
• Strong service maps
• Trace/log correlation
• Good dashboarding
• Alerting
• Kubernetes support

Because you're already emitting OTLP, migration is mostly changing the collector destination rather than touching application instrumentation. tasrieit.comoneuptime.com

Operational footprint

Typical production deployment includes:

• ClickHouse
• OpenTelemetry Collector
• SigNoz services
• PostgreSQL
• Kubernetes or Docker

Reasonably manageable if your platform team already runs stateful services.

Weaknesses

Not quite as polished as Datadog for:

• AI-assisted investigations
• SaaS integrations
• Enterprise governance
• Extremely large organizations

2. Uptrace

Uptrace takes an even stronger OpenTelemetry-first philosophy.

Highlights:

• OTLP only
• ClickHouse
• Excellent distributed tracing
• Low infrastructure footprint
• Very fast queries
• Simple deployment

It intentionally avoids proprietary agents.

If your engineers primarily troubleshoot through traces and logs, it's extremely attractive. uptrace.devuptrace.dev

Where it trails SigNoz:

• Smaller ecosystem
• Simpler dashboards
• Less sophisticated alerting
• Smaller community

3. Grafana LGTM Stack

Usually composed of

• Grafana Loki
• Grafana Tempo
• Grafana Mimir
• Grafana
• Grafana Alloy or OpenTelemetry Collector

Advantages

• Massive community
• Extremely mature
• Huge plugin ecosystem
• Best dashboarding
• Excellent Kubernetes integrations
• Easy to customize

Tradeoffs

You're really operating 4–6 distributed systems instead of one.

That means:

• upgrades
• storage tuning
• retention
• scaling
• backups

all become separate concerns.

This stack shines when you have dedicated observability engineers.

4. Elastic Observability

If your company already runs Elasticsearch clusters, this is compelling.

Pros

• Excellent search
• Great log analytics
• Mature security
• Machine learning
• SIEM integration

Cons

• More resource intensive
• Operationally heavier
• Less OpenTelemetry-centric than SigNoz or Uptrace

Native OpenTelemetry Support

Since you're already using OpenTelemetry, here's what migration generally looks like.

That means your instrumentation investment remains portable regardless of backend. tasrieit.comoneuptime.com

Total Cost of Ownership

This is where self-hosting gets interesting.

Your current spend:

$60k/month

≈ $720k/year

A self-hosted deployment's costs typically become:

• compute
• storage
• object storage
• backups
• engineer time

rather than ingest licensing.

For a mid-market SaaS company, a representative comparison looks like this:

Many organizations moving from premium SaaS observability to self-hosted report very large reductions in direct platform costs, especially once telemetry volumes reach multiple terabytes per month, though savings depend heavily on infrastructure pricing and staffing. uptrace.devuptrace.dev

For a team that already maintains Kubernetes, databases, and stateful infrastructure, the incremental operational burden is often much smaller than for organizations without a dedicated platform function.

Hidden Costs to Consider

The license savings aren't the whole story. Budget for:

• ClickHouse tuning
• Storage lifecycle management
• Disaster recovery
• Capacity planning
• On-call for the observability platform
• Version upgrades
• Collector fleet management

Fortunately, because you're already standardized on OpenTelemetry, changing backends later is much less disruptive than changing instrumentation.

What I'd Evaluate First

Given your environment, I'd narrow the proof of concept to:

1. SigNoz — best balance of unified experience, mature features, and OpenTelemetry-first design.
2. Grafana LGTM — if your platform engineers value maximum flexibility and are comfortable operating several distributed components.
3. Uptrace — if operational simplicity and low infrastructure overhead are top priorities and your observability needs center on application performance rather than an extensive visualization ecosystem.

For an organization currently spending around $720k/year, it's reasonable to invest a few weeks in a side-by-side proof of concept. I'd compare not only infrastructure cost, but also ingest throughput, query latency, storage growth, retention economics, alerting, RBAC, upgrade workflow, and how quickly engineers can move from an alert to correlated logs, metrics, and traces during an incident. Those operational characteristics often matter as much as the raw infrastructure bill.