Sentry

What Sentry actually is

Sentry is error tracking and application performance monitoring for software teams. When your application throws an exception, an SDK captures it with a full stack trace, the surrounding code context, breadcrumbs of what the user did beforehand, and environment metadata, then groups it with similar events so one noisy bug does not bury the rest. That grouping and de-duplication is the part competitors most often get wrong, and it is why Sentry became the default answer for application error monitoring.

The project predates the company. David Cramer started it in 2008 as a Django exception-logging side project at Disqus, and the company behind it was founded in February 2012 in San Francisco (source: Grokipedia's Sentry entry). Two decades of SDK work shows: official clients cover the major web, mobile, and server languages, plus edge and desktop runtimes, and framework integrations (Django, Rails, Laravel, React, React Native, Next.js) do most of the setup for you.

Sentry is bigger than error tracking now. The same subscription covers distributed tracing, session replay, release health, cron and uptime monitors, log ingest, and an AI debugging helper called Seer that is billed as a separate subscription. We treat it as an observability layer for application code rather than infrastructure monitoring: it tells you what broke in your code and for whom, not whether your disk is filling up. For that reason it sits in our monitoring & hosting comparison as the application-error specialist rather than a general-purpose monitoring suite.

One licensing caveat before the praise: the server code is public and a self-hosted edition exists, but Sentry has moved away from plain OSI open source over the years. Check the LICENSE file in the getsentry/sentry repository before assuming you can fork and embed it commercially. Self-hosting is real, but it is a substantial operations project — Sentry does not hide that the SaaS is the product it optimizes for.

Pricing: what you really pay

The published tiers are simple (source: sentry.io/pricing): a free Developer plan at $0 limited to one user, Team at $26/month billed annually, Business at $80/month billed annually, and Enterprise at custom pricing with a technical account manager. Team and Business both start with the same base quotas — 50,000 errors, 5 million spans, 50 replays, 5 GB of logs per month. What the extra money buys on Business is SAML/SCIM, advanced quota management, unlimited custom dashboards, and longer data retention, not more volume.

The base plan price is not the bill. Every quota has pay-as-you-go overage rates, and that is where Sentry gets expensive. On Team, errors beyond the included 50,000 cost $0.0003625 each in the 50K–100K band and step down to $0.00015 at 20M+ events (source: sentry.io/pricing). Spans, replays, logs, attachments, and continuous profiling are metered the same way, and UI profiling adds $0.25/hr when enabled. A misconfigured SDK that samples nothing can turn a $26 plan into a four-figure monthly invoice; we have seen teams need explicit rate limits and inbound filters in the first month.

Our practical advice: set team-level quotas and client-side sampling before you roll Sentry out widely, use the reserved-volume discounts (roughly 20 percent below pay-as-you-go, per third-party price breakdowns) once your volume is predictable, and keep the free Developer plan for side projects. The free tier is genuinely useful — error monitoring and tracing for one user, 10 dashboards — and we would rather see a solo developer on it than on nothing. Prices in USD; billing is monthly or annual, and annual pre-paid is what the headline $26 and $80 figures assume.

Two pricing details worth knowing before you commit. First, seats are not the constraint on paid plans — Team and Business both allow unlimited users, so growing the team does not grow the bill the way per-seat tools do. Second, the metered products are individually switchable: if you never touch session replay or logs, you do not pay for them, and turning a product on for one project does not silently enable it everywhere. That per-project control is the difference between predictable spend and surprise spend, and we would set it up on day one.

Performance & infrastructure

Sentry's SaaS runs on Google Cloud Platform (source: sentry.io/security), behind Sentry's own operations team with two-factor-authenticated VPN access for infrastructure changes and annual third-party penetration testing. The company publishes a security and compliance page covering SOC 2 and GDPR posture and a status history at status.sentry.io; this is one of the better-documented security practices pages among developer tool vendors.

Data residency is a first-class choice: when you create an organization you pick a US or EU region, and the EU region is hosted in Frankfurt, Germany with backups kept in the EU. EU residency is available on every plan at the same price as US (source: Sentry's EU region FAQ). Two constraints matter: the region cannot be changed after organization creation — migrating means rebuilding projects, alerts, and integrations in a new organization — and some account and integration metadata is still stored in the US even on EU-region organizations. There is no APAC data region.

On the product side, performance work lands on three levers: SDK-side sampling (adjust the tracesSampleRate rather than paying to send everything), event forwarding and inbound filters to drop known noise, and span-level scrubbing to keep PII out. Sentry's own ingest is fast enough that the practical latency question is your sampling config, not their pipeline. For hard numbers on ingest and query behavior we would point you at our benchmarks page for methodology, but we have not published Sentry-specific measurements, and we will not invent any.

On data handling, Sentry scrubs payloads and lets you configure server-side scrubbing rules for fields you never want stored, but the default posture is that whatever your SDK sends is what gets captured. Teams in healthcare or finance should write the scrubbing config before the first production deploy rather than after the first security review.

The self-hosted route flips the infrastructure question to you: the reference setup needs PostgreSQL, Redis, Kafka, ClickHouse, Snuba, and a symbolicator service, plus real ongoing upgrades. Budget a part-time operator, not an afternoon.

Where it falls short

The metering model is the main trap. Nothing breaks when you exceed quota — events start getting dropped or billed, depending on settings — so a traffic spike or a noisy library exception quietly changes your bill. We recommend treating Sentry spend as a per-environment budget with alerts of its own.

Noise is the second complaint, and it is mostly configuration debt. Without grouping tuning, source maps uploaded per release, and inbound filters, an application with chatty exceptions produces alert fatigue, and people start muting the very channels that matter. This is fixable, but it is real setup work in the first weeks.

There is no published uptime SLA for self-serve plans; contractual SLAs are an Enterprise sales conversation, so we cannot quote a number and won't guess one. Teams that need a contractual guarantee should get it in writing before signing.

Finally, Sentry is opinionated about data retention: the standard plans keep a limited window of event history (Business retains longer than Team, Enterprise negotiates). If your compliance process needs two years of error payloads, plan on exporting to your own storage rather than relying on the UI.

Who should pick this

We pick Sentry when application errors are the failure mode that costs you money — SaaS products, mobile apps, e-commerce backends, anything with real users hitting real code paths. The framework integrations and the grouping quality mean a small team gets value in an afternoon, and the free Developer plan makes it the obvious first tool for a solo builder.

We look elsewhere when the job is infrastructure monitoring (host metrics, disk, network — use a dedicated host-monitoring stack), when volume is huge and predictable enough that per-event pricing beats a flat-rate competitor, or when policy requires all telemetry to stay in APAC, which Sentry cannot offer.

For regulated teams: the compliance program is credible and EU residency is real, but note the US-held metadata carve-out and get the DPA reviewed.

Key takeaways

• Free Developer plan at $0 for one user; Team is $26/month and Business $80/month billed annually, with the same 50K-error base quota on both (source: sentry.io/pricing).
• Real cost is usage-based: overage on errors, spans, replays, and logs adds up fast without sampling and quota limits.
• SaaS runs on Google Cloud with US and EU regions (EU in Frankfurt, same price on all plans); no APAC region.
• The strongest error grouping, stack traces, and framework SDKs we know of — the main reason to choose it.
• Self-hosted edition exists but the license is not plain OSI open source and the deployment is operationally heavy.
• No public uptime SLA on self-serve plans; contractual SLAs are Enterprise-only.

Sources

• https://sentry.io/pricing/
• https://sentry.io/security/
• https://sentry.help/en/articles/13964378-sentry-s-eu-region-faq
• https://grokipedia.com/page/Sentry_error_tracking
• https://last9.io/blog/sentry-pricing