Given your constraints:

• ~90 engineers (large enough that observability UX matters, but not a hyperscale platform team)

• already standardized on OpenTelemetry

• want traces + metrics + logs in one UI

• want to avoid assembling and operating a DIY stack

…I would avoid the classic “pick Prometheus + Loki + Tempo + Grafana + glue” route unless your team specifically wants to become observability-platform maintainers. The leading self-hosted options break down into two categories: integrated platforms and composable stacks. SigNoz (+1 more citation)

Shortlist

PlatformBest fitSetup effortOngoing maintenanceNew Relic replacement qualitySigNozTeams wanting an OTel-native APM replacementLow–MediumMedium⭐⭐⭐⭐⭐OpenObserveCost-focused teams wanting a unified productLowLow–Medium⭐⭐⭐⭐HyperDXDeveloper-first debugging and logs/traces UXLowMedium⭐⭐⭐⭐Grafana LGTM StackTeams wanting maximum flexibility/controlMedium–HighHigh⭐⭐⭐⭐Elastic ObservabilityTeams already invested in ElasticMediumMedium–High⭐⭐⭐

---

1. SigNoz — closest self-hosted New Relic replacement

SigNoz is probably the first one I would evaluate for your situation.

It is built around OpenTelemetry and provides logs, metrics, traces, dashboards, alerts, and application monitoring in one product rather than making you stitch together separate backends. SigNoz (+1 more citation)

Why it maps well to your migration:

• Your existing OTel instrumentation should transfer cleanly.

• You keep vendor-neutral telemetry.

• Engineers get a New Relic-like workflow:

service overview

• trace exploration

• correlated logs

• latency/error dashboards

• alerts

SigNoz uses ClickHouse as its storage layer and includes its own OTel collector path for ingestion. SigNoz (+1 more citation)

Operational profile

Initial setup

• Docker Compose: straightforward

• Kubernetes: Helm deployment is typical

• Expect days, not weeks, for a production pilot

Maintenance

You still operate:

• ClickHouse

• SigNoz services

• storage

• upgrades

• backups

But you are not designing the observability architecture.

Where it shines

• SaaS engineering teams

• microservices

• OTel-first environments

• replacing APM vendors

Where it may hurt

• Very large log volumes can turn ClickHouse operations into a real platform responsibility.

• Some New Relic enterprise features may require customization.

My default recommendation for your team: pilot SigNoz first.

---

2. OpenObserve — lowest operational complexity

OpenObserve is another strong candidate if cost

Given your constraints:

• ~90 engineers (so platform ergonomics matter)
• Already standardized on OpenTelemetry
• Want to leave New Relic primarily for cost
• Want one integrated product, not "Grafana + Loki + Tempo + Mimir + Prometheus + X"

…I would narrow the field to SigNoz, Uptrace, OpenObserve, and (if you're willing to accept a somewhat younger ecosystem) HyperDX. I'd avoid a DIY Grafana LGTM deployment unless your SRE team actually enjoys operating observability infrastructure.

Here's how I'd compare them.

Platform	Unified UI	OTel-native	Self-hosted	Setup effort	Ongoing maintenance	Best fit
SigNoz	✅	✅	✅	Medium	Medium	Best overall New Relic replacement
Uptrace	✅	✅	✅	Low	Low	Small/medium engineering orgs wanting simplicity
OpenObserve	✅	✅	✅	Low-Medium	Low-Medium	Log-heavy workloads and cost efficiency
HyperDX	✅	✅	✅	Low	Medium	Modern developer experience
Grafana LGTM	Partial (multiple backends)	✅	✅	High	High	Teams already invested in Grafana

1. SigNoz (my strongest recommendation)

SigNoz is probably the closest thing today to an open-source New Relic or Datadog replacement.

Why it fits your requirements

• traces
• metrics
• logs
• dashboards
• alerts
• service map
• infrastructure monitoring
• OpenTelemetry-first architecture
• single UI instead of separate products

It was designed around OpenTelemetry rather than retrofitting OTel support later. signoz.io

Operational model

Under the hood it still runs several services:

• ClickHouse
• PostgreSQL
• OpenTelemetry Collector
• SigNoz backend
• Keeper components

…but they're deployed together, so you're managing one platform rather than assembling an observability stack yourself.

Setup

I'd call it:

⭐⭐⭐☆☆

Not trivial, but reasonable with Helm or Docker Compose.

Maintenance

⭐⭐⭐☆☆

Most maintenance revolves around:

• ClickHouse storage
• upgrades
• retention
• backups

The application itself isn't particularly demanding.

Pros

• closest experience to New Relic
• mature dashboards
• active development
• excellent OTel support
• good service dependency visualization

Cons

• ClickHouse still needs care
• larger footprint than Uptrace
• more moving pieces than the marketing suggests

---

2. Uptrace (my favorite if simplicity matters)

Uptrace has become surprisingly capable.

Its philosophy is:

Don't build a giant observability platform. Build a really good OpenTelemetry backend.

It provides

• traces
• metrics
• logs
• dashboards
• alerts
• service graph

in one interface. It stores telemetry in ClickHouse while using PostgreSQL for metadata. github.com

Setup

⭐⭐☆☆☆

Probably the easiest production deployment among the mature options.

Maintenance

⭐⭐☆☆☆

Less operational complexity than SigNoz.

Strengths

• fast UI
• very low resource usage
• easy to understand
• excellent tracing workflows
• good automatic dashboards

Weaknesses

Compared to SigNoz:

• infrastructure monitoring is lighter
• ecosystem is smaller
• fewer enterprise features

For a 90-engineer SaaS company, though, those may not matter.

---

3. OpenObserve

OpenObserve is increasingly popular because it's inexpensive to operate.

Strengths include

• unified observability
• ClickHouse-like performance
• object-storage friendliness
• efficient log indexing
• OpenTelemetry ingestion

It's particularly attractive if logs dominate your telemetry costs. betterstack.com

Setup

⭐⭐☆☆☆

Maintenance

⭐⭐☆☆☆

Generally lighter than a full Grafana stack.

---

4. HyperDX

HyperDX is newer but has a polished developer experience.

Interesting capabilities include

• logs
• traces
• metrics
• session replay
• ClickHouse backend
• OpenTelemetry-native ingestion

It's been gaining momentum recently. betterstack.com

I wouldn't yet call it as operationally proven as SigNoz for a company your size, but it's worth evaluating.

---

Why I wouldn't recommend Grafana LGTM

A lot of engineers immediately recommend

• Grafana
• Prometheus
• Loki
• Tempo
• Mimir

Technically it's excellent.

Operationally?

Not what you asked for.

You specifically said:

"without needing to build and maintain a custom stack"

LGTM is still multiple independent systems:

• separate upgrades
• separate storage tuning
• separate scaling
• separate failure modes

Even though Grafana provides one UI, you're still operating several backends. Community comparisons consistently rate it as the highest-maintenance option among self-hosted open-source stacks. betterstack.com

---

Maintenance comparison

Platform	Initial deployment	Upgrades	Storage tuning	Scaling
Uptrace	Easy	Easy	Low	Medium
OpenObserve	Easy	Easy	Low	Medium
SigNoz	Moderate	Moderate	Medium	Medium
HyperDX	Moderate	Moderate	Medium	Medium
Grafana LGTM	Hard	Hard	High	High

---

For a 90-engineer SaaS company

If I were making the decision today:

1. SigNoz — Best balance of capability, maturity, and New Relic-like experience. It offers the broadest "single-pane" observability with strong OpenTelemetry support and is the closest conceptual replacement for New Relic. signoz.io

2. Uptrace — If your priority is minimizing operational overhead while still getting unified traces, metrics, and logs. It's especially compelling if your SRE team is small and you'd rather spend time on reliability than running the observability platform. github.com

3. OpenObserve — If controlling infrastructure costs—particularly log storage and search—is a primary goal.

Unless your team already has deep Grafana expertise and is comfortable owning multiple backend services, I would not choose LGTM for the requirements you've described. It remains a powerful ecosystem, but it doesn't align well with your stated goal of avoiding a custom, multi-component observability stack.