# New Relic vs groundcover: A Complete Comparison for 2026
Observability pricing has changed dramatically over the past few years. The old model of **paying per host with separate charges for logs and other products** is no longer the only option. New Relic and groundcover have both moved away from it, but for very different reasons.
**New Relic** rebuilt its pricing around **data ingest and user types**, aiming to remove host-based licensing and make costs scale with telemetry instead. **groundcover** took a different path. Rather than focusing on pricing first, it redesigned the platform around a **bring-your-own-cloud (BYOC) architecture**, where telemetry stays inside your own cloud environment. Its flat per-node pricing is really a consequence of that architectural decision, not the goal itself.
That difference shapes almost everything else. **New Relic** is a mature, full-stack observability platform with more than 15 years of development behind it. Alongside its core monitoring capabilities, the company has spent the past two years investing heavily in AI through its Agentic Platform. **groundcover**, by contrast, is a newer platform built around **eBPF** and BYOC. Its value proposition isn't simply adding more features, but giving you modern observability **without requiring you to send your telemetry to a vendor-managed backend**.
You can also see those design choices reflected in day-to-day operations. New Relic's free tier is generous, but engineers who need advanced APM and infrastructure capabilities typically require **paid Full Platform user access**. With groundcover, every engineer can use the platform under the same node-based license. The tradeoff is that **you're responsible for running the infrastructure**, including the cloud resources needed for ClickHouse, VictoriaMetrics, and the rest of the platform.
Ultimately, **this isn't just a pricing comparison**. It's a comparison between two very different operating models. If your biggest concern is controlling SaaS licensing costs and adopting a mature, fully managed platform, New Relic is likely to be the better fit. If your priorities are **data residency, cloud ownership, and keeping telemetry inside your own environment**, groundcover offers a fundamentally different approach. In this comparison, we'll evaluate both platforms across **architecture, APM, logs, infrastructure monitoring, digital experience, AI, security, and pricing** to help you decide which model best matches your team's needs.
## Quick comparison at a glance
| Feature | New Relic | groundcover |
|---|---|---|
| **Deployment model** | SaaS only | BYOC (runs in your AWS/GCP VPC) |
| **Data storage** | New Relic-hosted (NRDB) | Always in your own cloud |
| **Instrumentation** | APM agents, eBPF (eAPM), or OTel | eBPF (zero code changes), OTel-native |
| **Pricing model** | Per-user + data ingest (GB) | Per node/month (data volume agnostic) |
| **Free tier** | Yes (100GB/month + 1 full platform user, forever) | Yes (12-hour retention, community support) |
| **Starting price** | Free, then $10 first user + $99/user (Standard) | $30/host/month (Pro, all features) |
| **Data ingest overage** | $0.40/GB Standard; $0.60/GB Data Plus | No ingestion fee (BYOC storage only) |
| **Custom metric surcharges** | No | No |
| **APM / distributed tracing** | Yes (primary strength) | Yes (Kubernetes-first) |
| **Log management** | Yes (all logs searchable, $0.40/GB) | Yes (volume agnostic, BYOC) |
| **Infrastructure monitoring** | Yes | Yes |
| **Kubernetes monitoring** | Yes | Yes (primary use case) |
| **Real user monitoring** | Yes (browser + mobile, Gartner Leader) | Yes (GA, no mobile) |
| **Session replay** | Yes | Yes (GA) |
| **Synthetic monitoring** | Yes | Yes (GA) |
| **LLM / AI observability** | Yes (AI Observability, June 2026) | Yes (eBPF-based, zero instrumentation, GA Aug 2025) |
| **AI SRE / investigation** | Yes (SRE Agent, Preview Feb 2026) | Yes (Agent Mode, GA March 2026) |
| **MCP server** | Yes (Preview, Agentic Platform) | Yes (active development) |
| **No-code AI agent builder** | Yes (Agentic Platform, Preview) | No |
| **Incident management** | Alerting + Applied Intelligence | Alerting only (monitors, no incidents) |
| **On-call scheduling** | Via integrations (PagerDuty/OpsGenie) | Not included |
| **Status pages** | No | No |
| **Cloud SIEM** | Limited (Security RX in preview) | No (compliance via architecture) |
| **SOC 2 Type II** | Yes | Yes |
| **HIPAA** | Yes (Data Plus) | Yes (BYOC data plane) |
| **FedRAMP** | Yes (Moderate, expanding to High) | No |
| **Air-gapped deployment** | No | Yes (On-Premise tier) |
---
## Platform architecture and philosophy
Start with the backend, because everything else in this comparison traces back to it.
### New Relic: unified NRDB backend with ingest-plus-user pricing
New Relic rebuilt its backend on NRDB, a single telemetry store that holds logs, metrics, traces, and events, all queryable through NRQL. The payoff shows up the moment you're actually investigating something: you can move from a service's APM view into its infrastructure metrics into its logs without context-switching, because it's genuinely the same database underneath.
The pricing model is where things get less elegant. New Relic bills on two axes: how much data you send, and what kind of user needs access to it. Basic users are free and can view dashboards and set alerts. Full platform users, the ones who can actually open a trace or dig into infrastructure metrics, cost $349/month on the Pro annual tier. Put eight engineers who all need that access on a team, and you're at $2,792/month in seat fees alone before a single gigabyte of telemetry shows up on the bill. The free tier (100GB/month, one full platform user, forever) makes this an easy platform to try and a more expensive one to scale.
### groundcover: BYOC-native with eBPF at the kernel level
groundcover starts from a different question entirely: what if the platform never had to see your data at all? Every deployment splits into a control plane (groundcover's cloud, handling routing and metadata) and a data plane that lives inside your own AWS or GCP account, running ClickHouse and VictoriaMetrics on infrastructure you own. The eBPF sensor runs as a DaemonSet on your Kubernetes nodes and pulls logs, metrics, traces, and events straight from the kernel, with nothing to install in your application code.
That separation is also where the bill gets complicated. The per-node license itself doesn't move with data volume, which is the headline pitch. But you're now paying your own cloud provider for the EC2, EBS, and S3 that the data plane needs, and groundcover's own TCO calculator puts that at roughly $23,000 a year for a 450-node deployment, on top of the license. Provisioning takes hours rather than the five minutes it takes to drop an agent onto a host, since you're standing up real infrastructure rather than just registering with a SaaS endpoint.
| Architectural factor | New Relic | groundcover |
|---|---|---|
| Data storage location | New Relic-hosted (NRDB) | Your own VPC |
| Instrumentation | APM agents, eBPF (eAPM), or OTel | eBPF (kernel-level, zero code) |
| Storage engine | NRDB (unified telemetry store) | ClickHouse + VictoriaMetrics |
| Query language | NRQL (proprietary) + PromQL | SQL + PromQL |
| Runtime requirement | Any environment | Kubernetes-first (Linux hosts also supported) |
| Cost pressure grows with | Engineer headcount needing full access | Node count + BYOC hosting |
| Vendor lock-in risk | Moderate (NRQL switching cost) | Low (OTel-native, open storage) |
[summary]
### Neither New Relic nor groundcover covers the full reliability picture
Both platforms focus on telemetry and alerting. Neither includes built-in on-call scheduling with phone and SMS delivery or customer-facing status pages as part of the core product. Better Stack brings all of that together alongside logs, metrics, and traces, so you can go from alert to post-mortem without switching tools.
**From heartbeat monitoring to incident timelines to status pages, one platform for the whole reliability lifecycle.** [Start free.](https://betterstack.com)
[/summary]
---
## APM and distributed tracing
The architecture split carries straight into how each platform actually traces a request.
### New Relic: dual-agent APM with thread profiling and NRQL-powered analysis
New Relic gives you two ways to instrument a service, and recommends you use both. Traditional APM agents are language-specific libraries that get you method-level traces and thread profiling, while the newer eBPF agent (eAPM) handles zero-code instrumentation at the kernel level for Kubernetes clusters. Running both means double the systems to keep updated, but it also means you get something groundcover can't offer: thread-level CPU profiling that shows exactly which function is burning cycles in production, without any added overhead. Infinite Tracing retains the most significant traces out of 100% of collected data rather than sampling blindly, which matters if you can't afford to miss the one trace that explains an outage.
### groundcover: eBPF-only APM with data residency baked in
groundcover skips the dual-agent question by not offering the traditional agent path at all. Everything runs through the same eBPF sensor that handles your logs and metrics, so there's nothing extra to install and nothing language-specific to maintain. The service map builds itself from kernel-level network data rather than agent-reported spans, which catches dependencies that instrumented tracing sometimes misses. What you give up is real: there's no thread-level profiling here, and no equivalent to Infinite Tracing's full-fidelity retention, because eBPF capture simply works at a coarser resolution than a language-aware agent can.
What you gain instead is that none of the captured request or response payloads, which can carry sensitive data, ever leave your VPC. For a compliance-sensitive team, that may matter more than method-level profiling ever will.
| APM / tracing | New Relic | groundcover |
|---|---|---|
| Instrumentation | APM agents or eBPF (eAPM), or OTel | eBPF only (zero code changes) |
| OTel support | Yes (native, no surcharge) | Yes (first-class, no surcharge) |
| Code-level profiling | Yes (thread profiling via APM agents) | No |
| Full trace retention | Yes (Infinite Tracing) | Configurable, BYOC storage |
| Service map | Yes (APM 360) | Yes (kernel-level network data) |
| Data storage | New Relic-hosted | Your VPC |
| Environment coverage | Any (agents) + Kubernetes (eAPM) | Kubernetes-first, Linux hosts |
| APM pricing | Included in data ingest + user license | Included in per-node license |
[summary]
### APM without per-host or per-seat math
Both New Relic and groundcover fold APM into a broader pricing model, but you're still paying either by user seat or by node to use it. Better Stack's tracing is priced purely by data volume with no span indexing fees and no cardinality penalties, and the AI SRE activates automatically during incidents to investigate root cause before you have to ask.
**Full-fidelity distributed tracing from every service, priced by volume with no surprises.** [Explore Better Stack tracing.](https://betterstack.com/tracing)
[/summary]
---
## Log management
Logs are usually where pricing philosophy gets tested hardest, because volume is unpredictable by nature.
### New Relic: all logs searchable, flat ingest pricing
New Relic's stance on logs is refreshingly simple: everything you ingest is searchable through NRQL, with no separate indexing decision to make and no archive tier hiding half your data. Pattern detection clusters similar messages automatically, and AI log alert summarization gives you a hypothesis the moment an alert fires, before you've even opened the dashboard. Long-term archival runs up to seven years without needing rehydration. The cost for that simplicity is $0.40/GB once you're past the free 100GB/month, which adds up fast for a high-volume team, but at least there's only one number to model rather than two interacting ones.
### groundcover: volume-agnostic pricing, but the bill doesn't disappear
groundcover's pitch goes a step further: the license itself doesn't care whether a node emits 1GB or 100GB of logs a month. That part is genuinely true. What's also true, and easy to overlook, is that your VPC storage bill still scales with volume, since ClickHouse has to live somewhere and that somewhere is your AWS or GCP account. The difference is who's charging for it. groundcover isn't marking up the data volume, your cloud provider is billing you directly for it, which tends to be meaningfully cheaper than a SaaS vendor's per-GB rate once you're at real scale. Log pipelines support OTTL-style processing, queries run through an embedded Grafana interface, and trace correlation is automatic since logs and traces share the same backend.
Where this actually flips in groundcover's favor is high log volume relative to node count. A team running a small Kubernetes fleet that happens to generate enormous log volume will find the per-node model dramatically cheaper than paying $0.40/GB for every byte.
| Log management | New Relic | groundcover |
|---|---|---|
| Billing model | $0.40/GB ingest (100GB/month free) | Per-node (data volume agnostic license) |
| All logs searchable | Yes (all ingested logs) | Yes |
| Query language | NRQL | SQL + PromQL via embedded Grafana |
| Data location | New Relic-hosted | Your VPC |
| Long-term archival | Yes (up to 7 years, no rehydration) | BYOC storage, retention configurable |
| Log-to-trace correlation | Yes | Yes |
[summary]
### Log search with no indexing tax
Both New Relic and groundcover avoid the indexed-versus-archived split that plagues some competitors, but you're still paying per gigabyte or footing your own VPC storage bill to get there. Better Stack stores logs in a unified warehouse with SQL querying and no per-event charges. You pay for what you send, and all of it is searchable.
**Unified log management with SQL search, live tail, and no indexing surprises.** [See how it works.](https://betterstack.com/logs)
[/summary]
---
## Infrastructure monitoring and cloud metrics
Neither platform penalizes you for cardinality the way some competitors do, which removes one common source of bill anxiety from this comparison. What's left is mostly a question of who gets to see the data and what environments it covers.
### New Relic: solid coverage, gated by who's holding a full platform seat
New Relic's infrastructure agent collects CPU, memory, disk, network, and process metrics across Linux, Windows, and macOS, and the no-agent cloud integrations for AWS, Azure, and GCP mean you're not deploying anything extra for cloud-native resources. Raw metrics stick around for 30 days, with aggregated rollups kept for 13 months, long enough for real trend analysis. The catch isn't the data, it's getting to it: viewing infrastructure metrics during an incident requires a full platform seat at $349/month, so the engineer who happens to be on call at 2am needs to already have that access provisioned, or they're locked out exactly when it matters.
### groundcover: deep Kubernetes views, open to everyone on the license
groundcover sidesteps the access problem entirely, since the per-node license already covers everyone who needs to look at the data. It runs on VictoriaMetrics inside your VPC, speaks PromQL natively, and the eBPF sensor auto-generates infrastructure metrics enriched with Kubernetes metadata. The depth here is genuinely impressive for anything Kubernetes: dedicated views for Pods, Nodes, Namespaces, Clusters, Deployments, Jobs, DaemonSets, StatefulSets, and Volumes, each with its own Metrics, Logs, Traces, and Events tabs, so you can go from a cluster-wide view down into one pod's traces without leaving the screen.
The tradeoff shows up the moment you step outside Kubernetes. There's no Windows or macOS agent story here at all, and metric retention is whatever you configure in your own BYOC storage rather than the multi-year rollups New Relic gives you out of the box.
| Infrastructure monitoring | New Relic | groundcover |
|---|---|---|
| Base pricing model | Data ingest + full platform user seats | Per-node (included in license) |
| OTel metric surcharges | No | No |
| Cardinality penalties | No | No |
| Cloud integrations (no agent) | Yes (AWS, Azure, GCP) | Yes (AWS, Azure, GCP) |
| OS coverage | Linux, Windows, macOS | Linux, Kubernetes-first |
| Kubernetes depth | Yes | Yes (primary strength) |
| Access to view metrics | Full platform user required ($349/month) | All users (covered by node license) |
| Raw metric retention | 30 days (+ 13 months aggregated) | BYOC storage, configurable |
[summary]
### Infrastructure metrics that connect to the full reliability workflow
Both New Relic and groundcover charge for infrastructure telemetry in ways tied to either user seats or node count. Better Stack takes a different approach: no per-host fees, no cardinality penalties, and infra metrics that live alongside uptime monitors, on-call schedules, and incident timelines.
**Infrastructure monitoring connected to alerting, on-call, and incident management, all in one place.** [Get started free.](https://betterstack.com)
[/summary]
---
## Digital experience monitoring
This is the one category where the gap between these two platforms isn't close, and it's worth saying so plainly before getting into specifics.
### New Relic: Gartner-recognized, and the only one with mobile coverage
New Relic Browser Monitoring covers Core Web Vitals, session replay, rage and dead click detection, and user journey analytics, and APM 360 stitches frontend sessions to backend traces so you're not guessing where a slow page load actually originated. Mobile monitoring covers iOS, Android, React Native, and Flutter natively, which is the headline difference in this section. New Relic was named a Leader in the 2025 Gartner Magic Quadrant for Digital Experience Monitoring for the second year running, a level of third-party validation groundcover simply doesn't have yet in this category. The same access restriction from infrastructure monitoring applies here too: a full platform seat is required to act on any of it.
### groundcover: solid web coverage, nothing for mobile
groundcover's RUM, now generally available, covers session replay, Core Web Vitals, user journey analytics, and native correlation with the backend traces the eBPF sensor is already capturing. Trigger an API call from a user's browser and you get the full distributed trace from frontend to backend in one view, stored inside your own infrastructure rather than handed to a vendor. Synthetic monitoring is GA too, and pricing is folded into the per-node license rather than billed per session the way some platforms do it.
The gap is mobile, full stop. There's no iOS or Android RUM here at all, which immediately rules groundcover out for any team that needs to monitor a native app alongside its web frontend.
| Digital experience | New Relic | groundcover |
|---|---|---|
| Browser RUM | Yes | Yes (GA) |
| Mobile RUM | Yes (iOS, Android, React Native, Flutter) | No |
| Session replay | Yes | Yes (GA) |
| Synthetic monitoring | Yes | Yes (GA) |
| Core Web Vitals | Yes | Yes |
| Frontend-to-backend correlation | Yes (APM 360) | Via eBPF trace correlation |
| Gartner DEM recognition | Leader, 2025 MQ (2x consecutive) | Not named |
| Access to DEM data | Full platform user required | All users (covered by node license) |
| RUM pricing | Per session (separate SKU) | Included in per-node license |
---
## AI capabilities
Both companies put real money behind AI in 2025 and 2026, and both stories are credible. Where they actually diverge is where the model does its thinking.
### New Relic SRE Agent and Agentic Platform: bigger ambitions, still a preview label
New Relic's SRE Agent launched at New Relic Advance on February 24, 2026 as an always-on teammate that runs full-stack diagnostics during incidents, leaning on Intelligent Root Cause Analysis to search the entity topology graph and apply probabilistic causal models rather than just pattern-matching on past incidents. Around it sits the Agentic Platform, which is the more ambitious piece: a no-code drag-and-drop builder for custom AI agents, an orchestration layer, RBAC and governance baked in, and MCP support, none of which groundcover currently attempts to match. New Relic NOW in June 2026 added AI Observability for production LLM monitoring, Preflight for catching issues in AI-generated code, and Notebooks for turning one-off investigations into reusable runbooks. The catch, and it's a real one: most of this, including the SRE Agent itself, is still labeled Preview as of June 2026.
### groundcover Agent Mode: smaller scope, but it's actually shipped and stays in your cloud
groundcover's Agent Mode went generally available in March 2026 at KubeCon Amsterdam, and the thing that sets it apart isn't ambition, it's where the inference runs. Agent Mode operates natively inside your own AWS environment via Amazon Bedrock, so the telemetry it reasons over never leaves your infrastructure, and you pay Bedrock's token costs directly with no markup. It builds first-class groundcover assets from its output (dashboards, monitors, queries) right in the environment you were already working in, and expanded to support Google Vertex AI in April 2026.
So the honest tradeoff is this: New Relic's Agentic Platform is reaching for something more comprehensive, a no-code builder and governance layer that groundcover doesn't even attempt. But New Relic's flagship agent is in Preview, while groundcover's is GA and keeps your data in-house the whole time. Which one wins depends on whether you need the bigger platform vision today or a smaller, shipped, compliance-friendly tool right now.
| AI capability | New Relic | groundcover |
|---|---|---|
| Autonomous investigation | Yes (SRE Agent, Preview Feb 2026) | Agent Mode (prompt-driven, GA March 2026) |
| No-code AI agent builder | Yes (Agentic Platform, Preview) | No |
| AI LLM/agent monitoring | Yes (AI Observability, June 2026) | Yes (eBPF-based LLM observability, GA Aug 2025) |
| MCP server | Yes (Preview, Agentic Platform) | Yes (active development) |
| AI inference location | New Relic cloud (external) | Your AWS/GCP environment (Bedrock/Vertex AI) |
| GA status | Preview (SRE Agent + Agentic Platform) | GA (Agent Mode) |
| Compliance-preserving AI | No (data leaves your environment) | Yes (AI runs in your VPC) |
[summary]
### AI that also wakes someone up
Both New Relic and groundcover have invested heavily in AI investigation. What neither one includes is a direct path from a root cause hypothesis to an on-call notification and a customer-facing status page update. Better Stack's AI SRE connects to the full incident lifecycle so the investigation and the response happen in the same place.
**Autonomous root cause investigation connected to on-call, incidents, and status pages.** [See the AI SRE.](https://betterstack.com)
[/summary]
---
## LLM observability
It's worth pulling this out as its own section, because it's the one place groundcover has a lead that isn't really about pricing philosophy at all, it's about what eBPF can see that an SDK can't.
### groundcover: zero-instrumentation capture, including services you never touched
groundcover shipped LLM observability in August 2025, and the sensor captures full LLM interactions, prompts, responses, token usage, latency, the works, with nothing to instrument. Out of the box it auto-detects OpenAI, Anthropic, and Amazon Bedrock calls and structures them into OTel GenAI Semantic Convention-compliant spans. Since LLM payloads routinely carry sensitive content, groundcover lets you configure field-level obfuscation while keeping the useful metadata (model, token counts) visible. And because this runs through the same BYOC pipeline as everything else, prompt content never leaves your cloud.
### New Relic: solid coverage, but only for what's actually instrumented
New Relic's AI Observability, introduced at New Relic NOW in June 2026, covers cost management, reasoning visibility, and quality guardrails for production LLM applications. The catch is that it requires instrumentation, either New Relic's own SDKs or OpenTelemetry, which means any service nobody got around to instrumenting is simply invisible to it. That's the structural difference here: groundcover's eBPF sensor can see LLM calls from third-party services or shadow integrations that were never deliberately wired up for observability, because it's watching the network rather than waiting to be told what to watch.
| LLM observability | New Relic | groundcover |
|---|---|---|
| Dedicated product | Yes (AI Observability, June 2026) | Yes (GA since August 2025) |
| Zero-instrumentation capture | No | Yes (eBPF) |
| Full payload visibility | Via SDK/OTel instrumentation | Yes (eBPF, all services) |
| OpenAI, Anthropic, Bedrock | Via SDK instrumentation | Native eBPF auto-detection |
| PII obfuscation | Via processors | Native configuration |
| Data location | New Relic-hosted | Your VPC |
---
## Incident management and alerting
Neither platform has a complete answer here, but they're incomplete in different directions.
### New Relic: smart alerting, external tools for the on-call part
New Relic's alerting handles threshold, anomaly, and NRQL-based conditions across every signal type, and Applied Intelligence groups related alerts together so you're not getting paged five times for the same root cause. AI log alert summarization hands you a hypothesis before you've finished opening the dashboard, which is a genuinely useful head start. What New Relic doesn't do natively is on-call: no phone or SMS delivery, no rotation scheduling. Teams plug in PagerDuty or OpsGenie for that layer, which tacks on roughly $245 to $415 a month for a five-person rotation, on top of whatever the New Relic license already costs.
### groundcover: alerts that route well, but nothing resembling an incident workflow
groundcover's alerting is built around monitors (threshold, anomaly, deployment-aware) plus issue auto-aggregation that collapses repeating problems into a single de-duplicated issue instead of a flood of duplicates. Routing covers Slack, PagerDuty, OpsGenie, MS Teams, and plain webhooks, and Planned Maintenance lets you silence alerts on a schedule. What's missing entirely, not just thin but absent, is anything that looks like incident declaration, responder assignment, or AI-generated summaries. The standard pattern is wiring groundcover's alerts straight into incident.io or PagerDuty, which lands in the same $100 to $400 a month range for a small team, on top of the groundcover license itself.
| Incident management | New Relic | groundcover |
|---|---|---|
| Native incident management | Alerting + Applied Intelligence | Alerting only (monitors) |
| Alert correlation / grouping | Yes (Applied Intelligence) | Issue auto-aggregation |
| On-call scheduling | External (PagerDuty/OpsGenie) | Not included |
| Phone/SMS delivery | External only | Via external tools |
| AI alert summarization | Yes (Applied Intelligence) | No |
| Alert routing | Yes | Yes (webhook, Slack, PagerDuty, OpsGenie) |
| Planned maintenance / silencing | Yes | Yes |
---
## Pricing comparison
This is the section where the abstract architecture conversation has to turn into actual numbers, and where the answer genuinely depends on your specific mix rather than either platform being flatly cheaper.
### New Relic: ingest-plus-user, with a free tier generous enough to matter
New Relic's free tier gives you 100GB/month of ingest, one full platform user, and unlimited basic users, forever, with no credit card required. Past that, Standard pricing starts at $10 for the first full platform user and $99/month for each additional user up to five, while Pro runs $349/user/month on the annual plan. Data ingest beyond the free allotment costs $0.40/GB Standard or $0.60/GB Data Plus. Run the numbers for eight engineers who all need full platform access on Pro, and you're looking at $2,792/month in seat fees before a single byte of telemetry counts against the bill.
### groundcover: per-node, plus whatever your cloud provider charges you on top
groundcover's tiers run Free ($0, 12-hour retention), Pro ($30/host/month, every feature included), Enterprise ($35/host/month, adds RBAC and unlimited retention), and On-Premise ($50/host/month, fully self-hosted). Billing is based on monthly average host count, not peak, so a short traffic spike won't set your rate for the whole month. The part that's easy to forget when you're just looking at the per-node number is BYOC hosting: your cloud provider bill for the EC2, EBS, and S3 the data plane runs on. groundcover's own TCO calculator puts that at roughly $21,500 a year all-in for 50 nodes, climbing to around $185,000 a year for 450 nodes once hosting is included.
**Scenario: 100 hosts, 8 engineers needing full access, 2.5TB/month telemetry**
| Cost component | New Relic (Pro, annual) | groundcover (Pro) |
|---|---|---|
| Full platform user licenses | $2,792/month (8 x $349) | Included in per-node license |
| Data ingest (2.5TB) | ~$960/month ($0.40/GB) | BYOC storage only (~$300/month) |
| Platform license | Included above | $3,000/month (100 nodes x $30) |
| BYOC hosting | None | ~$600/month |
| On-call (5 responders, PagerDuty) | ~$245-415/month | ~$245-415/month |
| **Estimated monthly total** | **~$4,000-4,200/month** | **~$3,900-4,300/month** |
Notice how close those two numbers land in this scenario. That's not a coincidence, it's the point: at a moderate ratio of engineers to nodes to data, neither pricing philosophy has an obvious edge. The gap opens up at the extremes. **Push the engineer count up while keeping nodes flat**, and New Relic's per-seat model starts compounding fast while groundcover's stays exactly where it was. **Push the log volume up while keeping the engineer count modest**, and New Relic's per-GB ingest fee can outrun groundcover's flat license plus BYOC storage bill. Model your actual ratio before trusting either vendor's marketing math, including your own.
| Pricing factor | New Relic | groundcover |
|---|---|---|
| Free tier | Yes (100GB + 1 full user, forever) | Yes (12-hour retention) |
| Per-user fee | Yes (full platform $349/month) | No |
| Per-node fee | No | Yes ($30-$50/month, all features included) |
| Data ingest billing | Yes ($0.40-$0.60/GB) | No (BYOC storage only) |
| High-water mark billing | No | No (monthly average) |
| BYOC infrastructure overhead | None | Yes (your cloud provider bill) |
| Compute pricing alternative | Yes (removes per-user fees) | N/A |
[summary]
### Enterprise observability without the multi-vendor model
Both New Relic and groundcover require separate tools for incident management, on-call scheduling, and status pages. Better Stack consolidates logs, metrics, traces, on-call scheduling, incident management, and status pages into one platform with one bill.
**Fewer vendors, fewer context switches, and a single place for the full reliability workflow.** [Talk to us.](https://betterstack.com)
[/summary]
---
## Security and compliance
Neither of these is a security platform first, but they get to "good enough" through completely different routes.
### New Relic: certifications now, a security product still taking shape
New Relic's security story today rests mostly on certifications: SOC 2, HIPAA on the Data Plus tier, and FedRAMP Moderate, with the company committing at New Relic NOW 2026 to push toward FedRAMP High and DoD Impact Level 4. Security RX, announced in preview that same year, connects vulnerability findings to engineering context, but it's a correlation feature rather than a Cloud SIEM, and it isn't trying to be one.
### groundcover: no security product, but a genuine compliance advantage by design
groundcover doesn't have a security product at all, no SIEM, no threat detection, nothing. What it has instead is a structural shortcut to compliance: since telemetry never leaves your VPC, you're not relying on a vendor's regional deployment options to satisfy data residency rules, you're satisfying them by default. SOC 2 Type II and ISO 27001 apply at the product level, HIPAA compliance follows naturally from the BYOC architecture, and the On-Premise tier extends all the way to air-gapped environments for government and defense customers who can't touch cloud SaaS at all. The one hard wall is FedRAMP, which isn't available here, so federal workloads are off the table regardless of how good the BYOC story otherwise is.
| Security and compliance | New Relic | groundcover |
|---|---|---|
| Cloud SIEM | Limited (Security RX in preview) | No |
| Workload protection | No | No |
| SOC 2 Type II | Yes | Yes |
| HIPAA | Yes (Data Plus) | Yes (BYOC data plane) |
| FedRAMP | Yes (Moderate, expanding to High) | No |
| Data residency (self-hosted) | No | Yes (BYOC or on-prem) |
| Air-gapped deployment | No | Yes (On-Premise tier) |
---
## What each platform genuinely lacks
**New Relic gaps worth knowing:**
1. Full platform user costs at $349/month create real access restrictions for larger teams.
2. Engineers without a full platform seat can't investigate APM, infrastructure, or digital experience data during an incident.
3. NRQL is proprietary, and the longer you build on it, the more it costs to leave.
4. No status pages and no native on-call scheduling.
5. SRE Agent and most of the Agentic Platform remain in Preview as of June 2026.
6. No data residency option; everything lives in New Relic's infrastructure, full stop.
7. Security RX doesn't yet match what a dedicated Cloud SIEM offers.
**groundcover gaps worth knowing:**
1. No security product of any kind: no SIEM, no threat detection, nothing.
2. No mobile RUM, which rules it out immediately for teams running a native app.
3. No incident management, on-call scheduling, or phone/SMS delivery.
4. No status pages.
5. The Kubernetes-first orientation makes it an awkward fit for fleets heavy on Windows, macOS, or plain VMs.
6. BYOC provisioning takes hours, and you're on the hook for ongoing VPC resource management afterward.
7. No FedRAMP authorization, so federal workloads are a non-starter.
8. BYOC hosting costs scale with data volume in ways that can still catch a log-heavy team off guard.
---
## Final thoughts
After comparing the two platforms, one thing becomes clear: **New Relic and groundcover aren't trying to solve the same problem**. They overlap in observability features, but they make very different tradeoffs when it comes to architecture, pricing, and deployment.
If you're looking for **a mature, fully managed observability platform**, New Relic is the stronger choice. It offers broad coverage across infrastructure, applications, mobile, and digital experience monitoring, along with a growing set of AI capabilities through its Agentic Platform. Organizations with strict compliance requirements may also find it easier to adopt, particularly if **FedRAMP authorization** is an important requirement.
groundcover takes a different approach. Instead of focusing on being the most feature-rich SaaS platform, it emphasizes **ownership and control**. By keeping telemetry inside your own cloud, it appeals to organizations where data residency, compliance, or cloud governance are major concerns. It's also a particularly strong fit for **Kubernetes-first environments**, and its node-based pricing can become more attractive as engineering teams grow. If AI-assisted investigations are part of your workflow, **groundcover's Agent Mode is already generally available**, while New Relic's SRE Agent is still in Preview.
Interestingly, **pricing isn't likely to make the decision for you**. For many organizations, the total cost of the two platforms ends up being surprisingly similar once you account for your infrastructure, data volume, and team size. The real difference is where those costs come from. With New Relic, you'll want to model **user access and data ingest**. With groundcover, you'll also need to factor in the cost of running and maintaining your own cloud infrastructure.
Ultimately, **the better platform depends on which operating model best fits your organization**. If you want a mature SaaS platform with minimal operational overhead, New Relic is the safer choice. If you value cloud ownership, Kubernetes-native observability, and keeping your telemetry under your control, groundcover offers a compelling alternative.
[summary]
### One thing neither covers: the full reliability layer
Neither New Relic nor groundcover includes uptime monitoring, on-call scheduling with phone and SMS, incident management, and customer-facing status pages as a unified product. Better Stack brings all of that together with logs, metrics, and traces, with usage-based pricing and no per-host fees.
**The full reliability lifecycle in one place. Start free, no credit card required.** [Try Better Stack.](https://betterstack.com)
[/summary]