The Datadog alternative that doesn't charge per host

Last verified against published pricing on September 27, 2026.

TL;DR: base14 Scout is an OpenTelemetry-native observability platform with signal-based pricing ($250/month platform fee + $0.10/M metrics + $0.25/M logs and traces). One metrics price covers every metric, custom metrics included. Datadog charges $5 per 100 custom metrics a month beyond the included allotment, which is $0.05 per time series, or about $0.19 per million points for a series reporting every 10 seconds. No per-host fees, no backend sampling, 30-day default retention, standard SQL across logs, metrics and traces. For a 100-host Kubernetes team, Datadog's published pricing with full log and span indexing comes to ~$36,270/month. Scout costs ~$5,375/month.

A platform team ran a two-day load test on 40 extra Kubernetes nodes. Datadog bills hosts on the busiest hours of the month, so the whole month was billed at 140 hosts instead of the 100 they run the rest of the time. The same invoice carried a custom metrics overage from a Prometheus check someone had enabled months earlier. Nobody had decided to spend more.

If you're evaluating a Datadog alternative, it's probably not because the dashboards or APM don't work. It's because the bill has several meters that move independently, and some of them move without anyone choosing to.

Why teams look for a Datadog alternative​

Datadog is a capable product with more than 1,000 integrations, full-resolution metric history for 15 months and a wide product range. Teams outgrow it for three structural reasons that get harder to manage as they scale.

Cost escalation you can't predict​

Datadog's pricing has more moving parts than most teams realize. Here's how the bill compounds:

Pricing as of September 2026. Published rates at datadoghq.com/pricing/list, annual billing. Contract pricing varies, but the billing mechanics work the same way.

Logging costs about $1.41/GB once you count both ingestion and indexing, assuming roughly 770K events per GB (an average log line of ~1.3 KB). Smaller log lines mean more events per GB and a higher effective rate. Three billing mechanics are easy to miss until the invoice arrives.

High-water mark billing​

Datadog counts hosts every hour. The monthly bill uses the highest hourly count after dropping the top 1% of hours, about 7 hours in a 30-day month. A short spike doesn't count. A load test, batch job or autoscaling event that lasts longer than that sets the host count for the whole month.

Custom metrics from integrations and tags​

A Datadog custom metric is one time series: a metric name with a unique combination of tag values, host included. Metrics sent through DogStatsD or a custom Agent check are custom, and so are metrics from the Prometheus and OpenMetrics integrations, log-based metrics and span-based metrics. Metrics from standard integrations are not. Adding a tag with many values, such as a customer ID, multiplies the count. Beyond the included allotment, each one costs $5 per 100 a month.

Dual-cost logging​

Datadog bills logs twice: $0.10 per GB to ingest them, then per million events to index them for search. Logs you ingest but don't index can still feed archives and log-based metrics, but you can't search them.

When a mid-stage fintech team reached 80 hosts and 300 GB of daily logs, their Datadog bill passed $18,000/month against a budget of $8,000. Most of the gap came from indexing 300 GB of logs a day, a cost they hadn't modeled.

Lock-in above the agent​

The Datadog Agent is open source (Apache 2.0), and Datadog accepts OpenTelemetry data through OTLP ingest in the Agent or an OpenTelemetry Collector. What stays Datadog-specific is everything built on top: Datadog tracing libraries and DogStatsD calls if you use them, dashboards, monitors, and runbooks that reference Datadog query syntax.

When your contract comes up for renewal, your options depend on how portable your telemetry pipeline is. If switching means re-instrumenting every service, switching is expensive.

OpenTelemetry is a CNCF project that standardizes how applications generate and export telemetry. With OTel instrumentation, your code produces vendor-neutral signals. You can point them at any compatible backend, including Datadog, without changing application code.

A separate meter for each product​

Datadog offers security monitoring, SIEM, CI visibility, RUM, synthetics, database monitoring, workflow automation and more. Each product has its own unit: per host, per GB, per session, per test run, per seat or per committer. If your team uses APM, logs and infrastructure monitoring, the rest is optional, but each product you add is another meter to forecast.

Already know you want to switch? Book a cost comparison call and we'll model your actual Datadog usage against Scout pricing.

base14 Scout at a glance​

Scout is a unified observability platform built on OpenTelemetry. Logs, metrics, traces, APM and LLM telemetry go into a single data lake with one query surface.

• Signal-based pricing: $250/month platform fee, $0.10 per million metrics, $0.25 per million logs and traces. One metrics price for infrastructure, Kubernetes, custom application and business metrics, whether counter or histogram. No per-host pricing and no separate indexing charge.
• OpenTelemetry-native: No proprietary agents. Your instrumentation works with any OTel-compatible backend.
• No backend sampling: Every trace, metric and log line you send is stored and queryable.
• 30-day default retention: Full-resolution data for 30 days across logs, metrics and traces. Extended retention is available.
• Standard SQL across logs, metrics and traces, in one data lake, instead of Datadog's separate metric query and log and trace search syntaxes.
• All features included: APM, logs, metrics, traces, LLM observability, custom dashboards and alerts. No feature gating.

Side-by-side: Datadog vs base14 Scout​

Pricing: context and cardinality cost more​

Datadog charges by data volume (GB), host count and custom metric count. Longer log lines cost more to ingest, and each new tag value on a custom metric is a new billable time series. Teams respond by trimming context and tags, which leaves less to work with during an incident.

Signal-based pricing works differently. A signal is one telemetry event: a log line, a metric data point, a trace span. You pay $0.10 per million metrics and $0.25 per million logs and traces, regardless of size. A full stack trace on an error span or request context on a log line costs the same as a bare one.

Custom metrics show the difference most clearly. Datadog charges $5 per 100 custom metrics a month, or $0.05 per time series, however often it reports. Scout charges $0.10 per million data points for every metric, custom or not. A series reporting every 10 seconds sends 259,200 points in a 30-day month (6 × 60 × 24 × 30), about $0.026 on Scout. At 15 seconds it sends 172,800 points, about $0.017. Put the other way, Datadog's $0.05 is about $0.19 per million points at a 10-second interval and about $0.29 at 15 seconds. A DogStatsD histogram counts as five custom metrics by default ($0.25 a month per tag combination) and a distribution with percentiles counts as ten ($0.50). On Scout a histogram data point is one metric point. For series that report less often, the gap narrows: at 60 seconds a series sends 43,200 points, about $0.004 on Scout.

Data retention: 30 days for logs and traces, longer metrics on Datadog​

Datadog indexes logs and spans for 15 days by default, with 3, 7 and 30-day options at different rates. Flex Logs, a lower-cost storage tier, keeps logs searchable for up to 15 months without rehydration. Otherwise, logs older than the index window come back from archives through rehydration, at $0.10 per compressed GB scanned plus indexing.

Scout retains 30 days of full-resolution data for logs, metrics and traces by default, with extended retention available. An issue that develops over three weeks falls outside a 15-day log index and inside Scout's default window.

Datadog keeps metrics at full resolution for 15 months on Pro and Enterprise. If long metric history matters most, that favors Datadog.

Sampling: Agent-side vs none​

Datadog APM samples traces by default. The Agent sets head-based sampling rates to target 10 traces per second per Agent, spread across services by traffic. An error sampler keeps up to 10 additional traces per second with error spans, and a rare sampler keeps some uncommon traces. You can raise rates in the Agent or tracing library, which raises ingestion.

A failure that doesn't mark a span as an error can still be dropped. When a logistics platform team investigated a payment bug affecting 0.3% of transactions, they couldn't find the traces in Datadog APM because sampling had discarded them. The investigation took a full shift: reproducing the issue in staging, cross-referencing partial logs, an executive review, and customer credits for the extended resolution time.

Scout doesn't sample what you send, so those traces would have been stored and queryable.

Lock-in: Datadog-specific layers vs OpenTelemetry​

Datadog ingests OpenTelemetry data, but dashboards, monitors and saved queries live in Datadog's own query syntax, and many teams still run Datadog tracing libraries and DogStatsD.

With Scout, you instrument your applications using OpenTelemetry SDKs and collectors. If you want to switch backends, add a second backend, or split workloads across platforms, you change collector configuration. Your application code stays the same.

Support: support tiers vs SRE partnership​

Datadog offers tiered support plans. Response depends on your plan level.

Every base14 customer gets an SRE partnership: assisted onboarding (first month free), fortnightly reliability reviews with a senior SRE, custom training for your team, and 24/7 on-call support with response times under 15 minutes via Slack. This is how Zinc Learning Labs went from "installing a tool" to "building an observability culture."

LLM observability: per LLM span vs included​

If your applications call LLM APIs (OpenAI, Anthropic, Bedrock, or any of 50+ providers), you need visibility into token usage, costs, latency and output quality.

Datadog bills this as Agent Observability, per LLM span: up to 40K LLM spans a month free, then $160 a month for the first 100K on annual billing. Scout includes LLM observability. Token tracking, cost analysis and prompt performance live in the same data lake as your infrastructure metrics and application traces, so you can correlate a spike in LLM costs with the deployment that changed prompt templates from one query surface.

APM and RUM​

Datadog APM costs $31 per host a month, plus indexed spans beyond the included allotment, and Datadog adds continuous profiling as a separate product. Datadog RUM is priced per 1,000 sessions, with session replay on top.

Scout includes APM as an app over your OpenTelemetry traces and metrics: RED metrics per service and operation, a service map, trace drill-down, grouped errors, database and messaging operations, and host and node health beside each service. RUM covers mobile apps (crashes, ANRs, app startup, screens, network calls and session timelines), and the React and Flutter web SDKs send browser telemetry, including Core Web Vitals, as spans that join backend traces. APM is included in the platform price. RUM is available on the Enterprise plan; talk to us for pricing. We're building session replay and code profiling with design partners, and teams that need them are welcome to join.

The real cost comparison​

This uses the same scenario as our other comparisons, so the numbers line up.

Scenario: 100 hosts running Kubernetes (30 pods/host), 430 GB logs/day, 7.5B trace spans/month, 7.5B metric data points/month, 20 engineers, annual billing. Datadog has no per-seat charge for the products in this estimate.

Signal volume ratio: 40% logs, 30% metrics, 30% traces (~25B total signals/month).

Datadog estimate​

Log events: 430 GB/day ÷ 1.3 KB average (assumed) = ~333M log lines/day × 30 = ~10,000M indexed events/month. Monthly ingestion: 430 × 30 = 12,900 GB.

Spans: APM includes 1M indexed spans per APM host per month. 100 hosts = 100M included, leaving 7,400M in overage.

Metrics: Datadog includes infrastructure and Kubernetes metrics in the per-host fee. Custom metrics are included up to 200 per host on Enterprise (100 on Pro). With 100 Enterprise hosts, 20,000 custom metrics are included. The estimate assumes the custom metric count stays within that.

Teams that index 20-30% of logs and a fraction of spans bring this closer to ~$15,400/month, and the rest of their data isn't searchable during incidents.

Pricing as of September 2026. Published rates at datadoghq.com/pricing/list, annual billing. Negotiated discounts lower the total but don't change the billing structure.

Datadog charges for these too, but they aren't in the estimate:

• Containers beyond 10 per host on Enterprise, at $0.002 per container hour or $1 per container per month prepaid. The scenario runs 30 pods per host.
• APM span ingestion beyond 150 GB per APM host per month, at $0.10 per GB.
• Custom metrics beyond 200 per host, at $5 per 100 per month, including log-based and span-based metrics.
• Hosts above the steady 100 when a spike lasts more than about 7 hours in a month.
• Log rehydration from archives, at $0.10 per compressed GB scanned plus indexing.
• RUM, from $0.15 per 1,000 sessions, and synthetics, at $5 per 10,000 API test runs and $12 per 1,000 browser test runs.
• On-Call at $20 and Incident Management at $30 per seat per month.
• Agent Observability for LLM spans beyond the free 40K a month.

base14 Scout estimate​

Here's the signal math for the same 100-host profile:

• Logs: 430 GB/day at ~1.3 KB average = ~333M logs/day = ~10B log signals/month.
• Metrics: ~1,185 time series per host (host, K8s, app, custom) at blended 60s/30s scrape = ~7.5B data points/month.
• Traces: 7.5B trace spans/month.

Scout meters all 7.5B metric points, including the host and Kubernetes metrics that Datadog includes in the host fee. An annual Datadog commitment runs to the end of its term, so plan the switch around your renewal date.

Scout has no per-host or per-seat charges. Your negotiated Datadog rate may be lower than list. The structure stays the same: Scout charges per signal, Datadog charges host fees, ingestion fees and indexing fees separately.

Estimating your signal count from a Datadog bill​

If you're coming from Datadog, here's how to translate your usage into Scout's signal-based pricing:

• Logs: Take your daily GB ingestion and divide by your average log line size (typically 1.0-2.0 KB). That gives you signals/day. Multiply by 30 for monthly signals.
• Traces: Each span is one Scout trace signal. If the Datadog Agent samples your traces, count spans before sampling, because Scout stores every span you send.
• Metrics: On Scout, all metric data points are signals, including infrastructure metrics that Datadog includes in host fees. Estimate your time series count (host metrics + K8s metrics + app metrics) and multiply by data points per month based on your scrape interval (43,200 for 1/min, 86,400 for 1/30s).

Ready to see the numbers for your specific infrastructure?​

Talk to our team and we'll build a comparison using your actual usage data.

How to switch from Datadog to OpenTelemetry​

You don't have to switch in one cutover. Teams usually move in these stages.

Adopt or extend OpenTelemetry instrumentation​

If you already send OTLP to Datadog, you have a head start. If not, install OTel SDKs and auto-instrumentation libraries alongside your existing Datadog Agent and tracing libraries. Both can run at the same time, and nothing changes operationally.

For a detailed walkthrough, see our guide to building a production-ready OTel Collector.

Point the collector at Scout​

Configure an OpenTelemetry Collector to export data to Scout. Keep a copy flowing to Datadog during the transition; the collector supports multiple exporters.

Run both in parallel​

Run both platforms side by side for 2-4 weeks. Rebuild the dashboards and monitors your team relies on, check alert parity, and confirm your team can answer the same questions in Scout that they answer in Datadog today. base14's onboarding team works with your engineers on dashboards and alerts during this stage.

Decommission the Datadog Agent​

Once your team is confident in Scout, remove the Datadog Agent and tracing libraries and cancel your subscription at the end of its term. Application code instrumented with OpenTelemetry doesn't change. If you later want to evaluate another backend, you change configuration, not code.

The migration takes 4-6 weeks for a mid-size team (~100 services). base14's onboarding team handles it hands-on during your first month, at no cost.

Who should switch (and who shouldn't)​

Switch to base14 Scout if​

• Cost predictability matters. Your Datadog bills have surprised you more than once, through host spikes, custom metric overages or log indexing.
• You want open standards. You're already using or planning to adopt OpenTelemetry. Scout is built for OTel-native teams.
• You need full cardinality. Your debugging workflow depends on finding specific traces or querying high-cardinality dimensions. Scout doesn't sample what you send, and tags don't change the price.
• Longer log and trace retention matters. Datadog's default index retention is 15 days. Scout keeps 30 days for every signal, with extended retention available.
• You value hands-on support. You want an SRE partner, not a ticket queue.
• You're a startup running lean. Scout's $250/month platform fee makes it a practical Datadog alternative for startups that need production-grade observability without a large annual commitment.

Stay on Datadog if​

• You rely on Datadog's security/SIEM products. Datadog has invested heavily in cloud security monitoring. If SIEM is a core requirement, their security product may be the right choice.
• You need Datadog's integration breadth. Datadog has more than 1,000 integrations. If you depend on niche integrations that don't emit OTel-native telemetry, verify coverage before switching.
• You need long metric history. Datadog keeps metrics at full resolution for 15 months.
• Your usage fits the included allotments. If custom metrics stay within the per-host allotment and you index a small share of logs, the Datadog bill is easier to predict.
• You're heavily invested in Datadog's collaboration workflows. If your team relies on Datadog Notebooks for incident collaboration or Watchdog for anomaly detection, those features don't have direct equivalents. Factor the retraining cost in.

Consider running both during transition​

Many teams run Datadog and Scout in parallel for a month or two. OTel instrumentation makes this straightforward, so the switch happens gradually rather than in one cutover.

What customers say​

"Improved reliability without increasing cost." -- Glomo

"Unified visibility across our stack, with faster MTTR and cost reductions." -- DPDZero

"Our engineers are excited to improve reliability. We're building an observability culture, not just installing a tool." -- Zinc Learning Labs

For what to expect after migration, see what factors actually influence MTTR and unified observability.

FAQ​

How long does migration from Datadog take?​

4-6 weeks for a typical mid-size team. base14's onboarding team handles the heavy lifting during the first month (free).

Can I run base14 and Datadog in parallel?​

Yes. OTel Collectors support multiple exporters. Run both platforms simultaneously until your team is confident in Scout.

What about Datadog's 1,000+ integrations?​

Most modern infrastructure and application frameworks support OpenTelemetry natively. For services that don't, the OTel Collector has receivers for common data sources. Check OpenTelemetry's registry for specific integrations.

Is base14 Scout enterprise-ready?​

Yes. SOC 2 Type II and ISO 27001 compliant. Bring-your-own-cloud (BYOC) deployment on AWS, GCP and Azure, where Scout runs in your own cloud account. Data residency options included.

How does Scout pricing work?​

You pay a $250/month platform fee plus usage: $0.10 per million metric data points and $0.25 per million logs and traces. The metrics price is the same for infrastructure, Kubernetes and custom metrics. On Datadog, a custom metric beyond the included allotment costs $5 per 100 a month, or $0.05 per time series. A series reporting every 10 seconds sends 259,200 points a month, about $0.026 on Scout, so Datadog's rate works out to about $0.19 per million points. There's no throttling and no sampling on Scout, and the price is linear in signal count.

Does Scout support alerting and dashboards?​

Yes. Custom dashboards, alerting rules and SLO tracking are included for all customers. No feature gating based on plan tier.

What is the best Datadog alternative for mid-size teams?​

base14 Scout is built for mid-size engineering teams (50-200 engineers) who need full observability without per-host pricing. Signal-based pricing keeps costs predictable as you scale, and the SRE partnership is included.

How much cheaper is base14 Scout than Datadog?​

For a 100-host Kubernetes team with 430GB/day of logs, 7.5B metrics, and 7.5B trace spans/month, Scout costs ~$5,375/month. Datadog's published list pricing with full indexing comes to ~$36,270/month. Teams that index less pay less, but have less data available during incidents. The structural difference is Scout's flat per-signal pricing versus Datadog's separate host fees, ingestion fees and indexing fees.

Start evaluating your Datadog alternative​

1. Book a demo to see Scout with your team's use case. No commitment, no sales pitch.
2. Get a cost comparison using your actual Datadog usage data. We'll show you the signal math for your infrastructure.
3. Start a parallel evaluation with OTel instrumentation. Keep Datadog running while you validate.

See how Scout works.

• No long-term contracts. Month-to-month.
• Assisted onboarding included at no extra cost.
• OpenTelemetry-native. Keep your instrumentation if you leave.

Related reading​

• How to evaluate an observability platform
• The New Relic alternative that doesn't charge per seat
• The CloudWatch alternative that doesn't stop at AWS
• The GCP monitoring alternative that doesn't price metrics by type
• Observability cost optimization: why the pricing model matters more than your data volume
• The problem with observability theatre
• Multi-cloud design and vendor neutrality