Error-tracking cost calculator: SaaS vs self-host.

What this calculator does and doesn’t

The calculator takes five inputs and produces one output: a 12-month total cost of ownership comparison across three options (Sentry SaaS, Sentry self-hosted, and urgentry self-hosted).

The inputs

• Monthly error events. The count of error events your SDKs send to Sentry each month. Pull this from Settings > Usage & Stats in your Sentry account, or from the stats_v2 API with category=error.
• Monthly spans. The count of distributed tracing spans your SDKs generate per month. This is often 10–100x your error count for services with tracing enabled. Same source: stats_v2 API with category=transaction (or category=span depending on SDK version).
• Monthly replays. The count of session replay sessions captured. Depends on your replaysSessionSampleRate and replaysOnErrorSampleRate settings and your monthly active user count.
• Your engineer hourly cost. The all-in rate for the engineer who would own the self-hosted deployment: salary plus benefits, amortized. Industry average for backend engineers in 2026 is $80–130/hour all-in. $100/hour is the default assumption in the worked examples below.
• VPS size preference. Small ($20–40/month, 4–8 GB RAM, sufficient for urgentry) or large ($55–200/month, 32 GB RAM, required for Sentry self-hosted).

The output

A 12-month TCO table with three columns: Sentry SaaS (your current bill annualized, or a modeled projection), Sentry self-hosted (infrastructure plus ops time), and urgentry self-hosted (infrastructure plus ops time at the lower maintenance estimate). Each column breaks down into sub-lines so you can see which component dominates.

What it cannot model

Three things sit outside the formula. First, the value of data residency: if your compliance environment requires that error telemetry stay in a specific geography or within your own infrastructure, that requirement changes the decision regardless of cost, and no dollar number captures it. Second, support SLA differences: Sentry SaaS includes support tiers with response time guarantees; self-hosted gives you the GitHub issue tracker and the community forum. The implicit insurance value of vendor support is real but not quantifiable without knowing your own risk tolerance. Third, the cost of lost observability during a self-host incident. When the tracker goes down, you fly blind. That cost is covered in its own section below.

Interactive calculator

The Sentry SaaS side of the math

Sentry bills five distinct line items on the Team and Business plans. Each has an included quota and an overage rate. Getting the structure right before plugging in numbers matters because overage is charged in blocks, not at a per-unit rate.

Errors

The base Team plan includes 50,000 errors per month. Business includes more. Overage on errors is roughly $0.000089 per error after the included tier, sold in blocks. A team sending 500,000 errors per month on the Team plan pays for 450,000 overage errors. At $0.000089 per error, that is roughly $40/month in error overage alone, on top of the base plan cost of approximately $26/month.

Spans (the one that surprises teams)

In August 2025, Sentry cut the included span quota from 10M to 5M per month on both Team and Business plans. Teams with distributed tracing enabled saw their effective span cost double without changing any code. The per-span overage rate after the included tier is approximately $0.0000088 per span. A service handling 100 requests per second with an average of 40 spans per transaction generates roughly 10 billion spans per month. That team owes overage on essentially their entire span volume.

Overage is billed in blocks with ceiling division. If your overage is 1,001 spans past a block boundary, you pay for the full next block. This structural detail means that the model you use for the math matters: a simple linear rate underestimates the actual invoice.

Replays

Session replay costs approximately $0.0029 per replay after the included tier. For a team with 100,000 MAU at 10% session sampling, that is roughly 10,000 replays per month. After the included quota, overage runs approximately $29/month. The lever here is replaysSessionSampleRate: cutting it from 0.10 to 0.01 drops replay volume by 90%.

Logs

Sentry’s structured log ingestion product launched in 2024 and carries its own per-line-item meter. Log volume is the most dangerous line item to leave unmonitored because it scales with debug verbosity, not user traffic. A service with DEBUG-level logging in production can generate hundreds of millions of log lines per month. Filter to WARNING or above before sending, or set a log-level filter in Relay.

How to read your own usage report

Pull three months of actual data before building any model. Three paths into the data:

• Settings > Usage & Stats in the Sentry UI for a visual monthly breakdown by category.
• The /api/0/organizations/{org_slug}/stats_v2/ endpoint with a date range and category filter for daily granularity. This is the authoritative source and the one the billing system uses.
• The billing CSV at Settings > Billing > Usage & Payments for the exact invoice line items, included quotas, and overage charges per billing period.

Cross-reference the API data against the billing CSV to confirm your model matches what Sentry actually charged. A 5% discrepancy usually points to a reserved capacity add-on or seat-based charge not captured in the event-count model.

The self-host side of the math

The self-host cost has two components. Infrastructure is the easy part. Engineer time is the one most teams undercount.

VPS cost

For urgentry: a 4 vCPU, 8 GB RAM instance handles steady-state ingest at 400+ events per second with 52 MB resident memory for the urgentry process itself. A Hetzner CPX31 (~$15/month) or a DigitalOcean 8 GB Droplet (~$48/month) covers most small and mid-size teams. Annualized: $180–576/year for the instance, plus $10–20/month for backup storage.

For Sentry self-hosted: the 20-container Docker Compose stack needs 32 GB RAM in practice (ClickHouse alone uses 8–12 GB under load). A Hetzner CCX33 at ~$60/month is the cheapest adequate option. Annualized infrastructure lands at $720–900/year for Hetzner; $1,800–3,600/year on AWS.

Engineer ops time

For urgentry: routine maintenance runs roughly 30 minutes per month (monitoring disk usage, reviewing alerts, confirming the process is healthy). The annual upgrade is a binary swap plus a smoke test: about 30–60 minutes per year. At $100/hour, ops time annualizes to $650–800/year.

For Sentry self-hosted: routine maintenance runs 4–8 hours per quarter based on operator reports from the getsentry/self-hosted issue tracker. Major version upgrades add 8 hours to multiple days per event when a ClickHouse schema migration stalls or a Kafka topic structure changes. At $100/hour, ops time annualizes to $1,600–5,600/year, excluding incidents.

What to leave out

Do not count bandwidth costs unless you have an unusual geographic setup or large binary attachments. For most teams, inbound telemetry on a major VPS provider is either free or under $5/month. Do not count disk costs separately if you have chosen a VPS with adequate included SSD; the block storage add-on only matters when you outgrow the root volume after 12+ months. Do not count the one-time setup time in your ongoing TCO: setup costs are real, but amortized over two or three years they become noise against the monthly ops and infrastructure lines.

Worked example 1: small team, ~500k errors/month

A five-person startup. Web app plus one backend service. Error volume: 500,000 per month. Span volume: 2M per month (moderate tracing, traces_sample_rate=0.1). Replays: 5,000 per month. No logs ingested to Sentry yet.

Sentry SaaS: Team plan

12-month SaaS cost: approximately $852–912.

urgentry self-hosted

VPS: Hetzner CPX21 (4 vCPU, 4 GB RAM), ~$8/month. Backup storage: ~$3/month. Ops time: 30 min/month at $100/hour = $50/month. Annual upgrade: 1 hour = $100/year.

12-month urgentry cost: (11 months × $61) + (1 upgrade month at $161) = approximately $832.

Break-even and conclusion

At 500k errors per month, Sentry SaaS and urgentry self-hosted cost almost exactly the same over 12 months when the engineer rate is $100/hour. The break-even sits around 600k–700k errors per month: above that volume, SaaS cost grows faster than self-host cost. Below 500k errors, Sentry SaaS is the cleaner choice for a five-person team because the ops overhead of self-hosting consumes the savings. At $150/hour, the break-even shifts up toward 1M errors per month because the time line item is larger.

Worked example 2: mid team, ~5M errors/month plus 10M spans

A twenty-person Series A company. Three backend services, one web app. Error volume: 5M per month. Span volume: 10M per month (broad tracing, mixed sample rates). Replays: 20,000 per month. No Sentry logs yet. Business plan.

Sentry SaaS: Business plan

12-month SaaS cost: approximately $6,840–6,960.

urgentry self-hosted on Hetzner CCX33

VPS: Hetzner CCX33 (8 vCPU, 32 GB RAM), ~$60/month. Backup storage and object storage: ~$15/month. Ops time: 30 min/month at $100/hour = $50/month. Annual upgrade: 1 hour = $100/year.

12-month urgentry cost: infrastructure ($75/month × 12 = $900) + ops time ($50/month × 12 = $600) + upgrade ($100) = approximately $1,600.

Where the engineer-hour line item starts to matter

At this team size and event volume, urgentry self-hosted costs roughly $5,200–5,400 less per year than Sentry SaaS. The savings cover 52–54 hours of engineering time. If the person managing the deployment has other infrastructure responsibilities and the urgentry work is genuinely additive (30 min/month above what they would do anyway), the financial case is clear.

If the self-host deployment creates a new on-call rotation or adds a new category of incident the team was not previously responsible for, price those hours honestly against the $5,200 savings. A single four-hour incident per quarter ($1,600/year at $100/hour) still leaves the team roughly $3,600 ahead of the SaaS bill. Two major incidents in a year ($800 each) narrows the advantage further.

Worked example 3: large team, ~50M errors/month

A fifty-plus-person company at scale. Dozens of services. Error volume: 50M per month. Span volume: 200M per month. Replays: 100,000 per month. Custom enterprise pricing on Sentry SaaS.

Sentry SaaS: custom enterprise

At 50M errors per month, the team is well into enterprise contract territory. Sentry does not publish per-event rates for enterprise plans. Based on publicly available information and the per-unit rates on self-serve plans, an enterprise contract at this volume typically runs $8,000–25,000 per month depending on the scope of the agreement, committed terms, and which product surfaces are included. The range is wide because enterprise pricing involves negotiation, committed spend, and bundled support tiers.

For this example, assume a mid-range enterprise contract at $12,000/month. Annualized: $144,000.

Self-host on multiple VPS or Kubernetes

At 50M errors per month and 200M spans, a single urgentry binary on a $60/month VPS is no longer the right architecture. The deployment moves to either multiple replicated urgentry instances behind a load balancer or a Kubernetes cluster with horizontal pod autoscaling. Infrastructure cost at this scale on Hetzner: three CCX33 nodes plus load balancer plus managed object storage runs approximately $250–350/month. On AWS with EKS, the equivalent cluster costs $1,200–2,500/month.

Ops time at this scale also changes shape. A dedicated fraction of a platform engineer’s time (say, 5 hours per month for a team that already runs Kubernetes) plus quarterly upgrades and monitoring adds up to roughly $7,000–12,000/year at $100/hour.

12-month urgentry self-hosted cost (Hetzner, conservative ops): infrastructure ($3,600) + ops time ($7,200) = approximately $10,800.

Where data residency starts to dominate

At $144,000/year SaaS versus $10,800/year self-hosted, the financial case for self-hosting is strong regardless of which number you use for engineer time. The decision at this scale is almost never purely financial. Data residency, compliance, and the ability to customize the ingest pipeline for the specific shape of your telemetry carry weight that pure cost does not capture.

Teams in regulated industries (healthcare, finance, defense) often arrive at self-hosting from the compliance direction before they run the cost numbers. At 50M events per month, the cost savings confirm a decision that was already made on other grounds.

Sensitivity analysis

Which input moves the TCO answer most? The answer varies by scenario, but the pattern is consistent across team sizes.

Engineer hourly cost

This input dominates in every scenario where the self-host event volume is below 50M per month. A $50 change in the hourly rate (say, $75/hour versus $125/hour) shifts the self-host annual TCO by $600–1,200. For urgentry at 30 min/month, the ops time component is relatively small, so the sensitivity is modest. For Sentry self-hosted at 4–8 hours/quarter, a $50 change in hourly rate shifts the annual TCO by $1,200–2,400. Teams that underestimate their effective hourly cost produce self-host TCO numbers that look better than they are.

Event volume

Event volume drives the SaaS side of the equation. On the self-host side, urgentry’s resource consumption scales with event rate but stays well within a single VPS until you exceed several thousand events per second. Volume below 10M errors/month does not change the VPS cost; it only changes what Sentry charges. Span volume matters more than error volume on the SaaS side because the span quota is lower relative to typical team usage.

Spans and replays

After engineer hours, the span line is the most volatile SaaS input. Because the included quota dropped from 10M to 5M in August 2025, teams with broad distributed tracing instrumentation land in overage territory faster than they expect. Halving traces_sample_rate from 0.2 to 0.1 cuts span volume in half and can reduce a monthly Sentry bill by 20–40% for span-heavy teams. Replays matter when session sampling rates are high; cutting replaysSessionSampleRate from 0.10 to 0.01 reduces replay volume 90%.

The short answer

If you only have time to adjust one input, adjust your engineer hourly rate. Teams that use $0 or “free” for ops time produce self-host TCOs that look unrealistically cheap. Teams that use $100/hour as a default arrive at an honest comparison faster. After that, run the sensitivity on span volume if you have distributed tracing enabled.

The number that’s never on the calculator

Every TCO calculator produces a comparison between two costs. It does not produce a comparison between “cost of running error tracking” and “cost of not running error tracking.” That second number is real and often larger than either option in the calculator.

An error monitoring system that goes down means you lose real-time visibility into production failures. If the self-hosted tracker you chose has an upgrade incident at 11pm on a Tuesday, you are not flying blind on a quiet night. You are flying blind during the window when something is already broken, because the tracker tends to become relevant exactly when the application is under stress. That correlation is not coincidence: high-traffic events stress both the application and the monitoring infrastructure simultaneously.

The TCO calculator for error tracking only makes sense alongside an estimate of the cost of a production outage that goes undetected for 30, 60, or 120 minutes. For a consumer app with 100,000 active users, a 60-minute undetected payment processing failure might cost more than an entire year of error tracking. For a B2B SaaS with an uptime SLA, the same incident might trigger SLA credits. For a developer tool with a technically sophisticated audience, an unacknowledged outage that users notice before the team does damages trust in ways that are hard to recover.

The right conclusion from this is not “always pay for the most expensive option.” It is: make sure the option you choose has a reliability profile you are comfortable with. urgentry runs as a single binary with a simple failure mode; if the process crashes, you restart it. Sentry SaaS has redundant infrastructure and a vendor-managed reliability guarantee. Sentry self-hosted has neither the simplicity of the former nor the guarantee of the latter. Factor this into the comparison, even if the calculator cannot.

How to actually run this for your team

Start with three pieces of data from your Sentry account. Pull three months of usage from Settings > Usage & Stats or the stats_v2 API. Take the average monthly value for errors, spans, and replays. That average is your baseline.

Pull the last three invoices from Settings > Billing > Usage & Payments. Divide the total by three to get your average monthly bill. Multiply by twelve. That is your annualized SaaS cost. If your usage has been growing, project it forward at the same growth rate rather than using the current average.

Build the self-host side with two inputs. First, find the VPS price for the size that fits your event volume (the worked examples above give anchor points). Second, estimate your ops time honestly. If you manage other infrastructure, how many hours per month do you spend on it? How many of those hours would urgentry add? Use $100/hour as the default rate, or use your team’s actual blended engineering cost.

Compare the two annualized numbers. If the SaaS cost exceeds the self-host cost by a margin that covers a reasonable estimate of incident risk (say, one four-hour incident per year), self-hosting is worth evaluating further. If the numbers are close or self-hosting is cheaper only in the best case, stay on SaaS or find the sampling lever that makes SaaS cheaper.

Do not make the decision based on the infrastructure cost alone. The VPS is always cheaper than the SaaS bill past a low threshold; that comparison is misleading without the ops time line item. Include the time, use a real hourly rate, and let the number lead.

Frequently asked questions