Sentry self-hosted vs SaaS: how much you really save for a Brazilian startup

The question reaches the inbox almost every week of those who follow the blog: is it worth dropping Sentry SaaS and self-hosting? The honest answer starts with a "depends" — and most content circulating on the subject treats the "depends" as if it were evasive. It isn't. There are three hard variables that decide the math — event volume, team operational capacity, and compliance requirement — and each has a number you can measure before making the decision.

This post is the long version of the answer. If you're CTO of a Brazilian startup at the stage between five and fifty engineers, reading the Sentry bill rise month by month, what comes below serves as an explained calculator — not as a sermon for or against self-hosted. At the end there's a table with twelve criteria, an FAQ section for questions that didn't fit in the body, and three well-defined profiles of when each path makes sense.

TL;DR — 30-second version

Sentry SaaS starts at US$26/month on the Team plan — covers 50 thousand errors/month and five users. For Brazilian startup with serious traffic, the bill rises fast to the US$80–200/month band (R$400–1,000/month at R$5/USD exchange rate), and at scale-up easily reaches US$300–500/month (R$1.5k–2.5k/month). It's predictable and asks nothing of the team beyond the credit card.

Self-hosted is "free open-source" in the marketing, but the software runs ten to twelve containers — PostgreSQL, Redis, Kafka, ZooKeeper, ClickHouse, Symbolicator, and four distinct Sentry processes. Asks between 8 GB of RAM and 4 vCPUs on a dedicated server, plus storage, backup, quarterly updates, and the time of the dev who takes care of all that.

It's worth self-hosting when: (a) volume passed 1 million errors/month and the SaaS bill started to hurt, (b) the team has operational capacity to take care of complex stack without becoming a bottleneck, or (c) compliance demands data on own server. It's not worth it for team of one to three people focused on product, or low volume where the SaaS is just budget noise.

Interesting middle ground: GlitchTip — open-source MIT, compatible with the existing Sentry SDK, runs on Postgres + Redis (no Kafka, no ClickHouse, no ZooKeeper). Covers 80% of Sentry's value with 20% of the operational overhead.

What Sentry SaaS does well

Before discussing cost, it's worth recognizing what you're paying for. Hosted Sentry delivers a combination that's hard to reproduce at home without investing several team quarters:

• Pre-configured stack. You create an account, install the SDK in the application, and in fifteen minutes you have errors arriving. Zero server, zero config file, zero backup to schedule.
• Integrated Performance Monitoring. Distributed tracing, n+1 queries detection, slow database queries — all on the same dashboard where you're already looking at errors.
• Session Replay. Anonymized recording of the user session up to the error moment. Worth gold for debugging scenarios that don't reproduce in dev.
• Mature alerting. Integration with Slack, PagerDuty, Microsoft Teams, email, and webhooks. Fine rules — alert only when error rate doubles in 5 minutes, only in production, only for authenticated users.
• Issue tracking + sync. Links issue to Linear/Jira/GitHub Issues automatically. Resolve on the tracker side, close on the Sentry side.
• Continuous Profiling. Profile in production without perceptible overhead, discovering CPU bottlenecks without needing to reproduce locally. Available only in the SaaS version — self-hosted doesn't yet support.
• Technical support. Depending on the plan, human team responding within four business hours.

That whole package costs US$26/month on the entry plan. For a team of three people starting a SaaS, it's literally the best use of R$130/month that exists on the shelf.

The SaaS math, line by line

The Sentry SaaS catch isn't the entry price — it's the curve. Let's detail for Brazilian startup at three different stages:

Stage 1 — first product, R$10–30k MRR.

• Team plan: US$26/month (50 thousand errors/month, 5 users)
• Total: R$130/month

That's the band where no one should be thinking about self-hosted. R$130/month is almost budget noise — spending four CTO hours installing monitoring infrastructure costs more than two years of subscription.

Stage 2 — product growing, R$50–100k MRR.

• Business plan: US$80/month (300 thousand errors/month included)
• Extra performance events: US$15–30/month
• Session Replay: US$25–50/month
• Additional users (10 devs): US$50/month
• Total: US$170–210/month = R$850–1,050/month

Here the bill starts appearing in the monthly financial report. It doesn't hurt yet, but you notice.

Stage 3 — scale-up, R$200k+ MRR, 20+ engineers.

• Business plan with adjustments: US$200–300/month base
• Performance events: US$50–100/month
• Session Replay: US$100/month
• Users: US$100/month
• Total: US$450–600/month = R$2,250–3,000/month

At that stage, R$30k/year on error tracking starts competing with partial engineer salary. It's the point where the conversation "is self-hosting worth it?" stops being theoretical and becomes scheduled meeting.

The real pain of the Business plan isn't the base price — it's the multiplication by add-ons. Performance, Replay, Profiling, Cron Monitoring, Code Coverage — each comes with its own event count and its own bill. It's predictable, but it's not cheap.

Sentry self-hosted — what it is exactly

The official getsentry/self-hosted folder installs a stack that has the following form, in production:

Sum: about 8 GB of RAM in firm use in a small cluster, 12 containers, and that's the floor. At higher volume, Kafka and ClickHouse get hungry pretty quickly.

The less-discussed catch is the license: since 2019, Sentry licenses the self-hosted product under BSL 1.1 (Business Source License). It's open-source in form — you read the code, modify, contribute — but it has a clause that prohibits offering Sentry as commercial service to third parties. For a company using internally, it's irrelevant. For an agency that thought of including error tracking in the package sold to the customer, it's prohibitive.

Cluster setup — high-level steps

The official documentation assumes you'll run ./install.sh on an Ubuntu server, and then docker-compose up -d administers the stack. For those operating modern cluster, the path is slightly different:

1. Define job spec with 12 containers. HeroCtl accepts config file of up to a few thousand lines, and the translation from official compose to job spec is mechanical. Reserve a work shift to do this right — including depends_on, health checks, and boot orders (ZooKeeper before Kafka, Postgres before sentry-web, and so on).
2. Persistent volumes for Postgres, ClickHouse, and Kafka. All three have data you can't lose. ClickHouse is what grows the most — raw events become analytic rows and the disk fills. Reserve 50 GB initial SSD, adjust to 200 GB after six months if volume justifies.
3. Backup, and backup of each one separately. The most common error in self-hosted is doing backup only of Postgres, forgetting that events live in ClickHouse. Postgres has metadata (project, user, alert configuration); ClickHouse has the error history. Backup of just Postgres recovers the empty interface.
4. Automatic TLS on internal domain. The panel needs to be accessible by devs with valid certificate — no -k on curl, no yellow warning in Chrome. HeroCtl cluster solves this automatically with Let's Encrypt; on other stacks you add an operator or configure manually.
5. Quarterly updates. Sentry releases major version every three months, and the self-hosted requires Postgres schema migration + partial ClickHouse reindex. Reserve a maintenance window each release — generally between 15 minutes and two hours, depending on accumulated volume.

Total install time: 4 to 8 hours for competent dev who knows the product, 2 to 3 days for someone learning from scratch. That's the clean setup. Add 50% for debugging the real case (wrong internal DNS, unmounted volume, Kafka stuck waiting for ZooKeeper to come up).

GlitchTip — the "Sentry-lite" many forget

GlitchTip is the alternative that appears little in comparisons and deserves highlight. It's open-source MIT (not BSL) — you use it for any purpose, including commercial, no clause. It was specifically designed to cover Sentry's 80/20 case.

How "Sentry SDK compatible" works: the Sentry SDK sends events to a standard HTTP endpoint. GlitchTip implements that same endpoint. You change the URL on Sentry.init({ dsn: ... }) of your application to point to GlitchTip and nothing else changes — not code, not dependency, not build. Reverse migration is also direct.

GlitchTip stack:

• PostgreSQL
• Redis (queues)
• Django web
• Celery worker

It's 4 containers vs 12 of Sentry. Resources: 2 GB of RAM, 1 vCPU. Runs comfortably on a US$12/month droplet. Accepts the same SDKs (JavaScript, Python, Go, Ruby, PHP, Java, .NET, mobile) without change.

What GlitchTip doesn't have:

• Session Replay
• Continuous Profiling
• Performance Monitoring at the level of Sentry detail (has simplified version)
• Distributed tracing with full waterfall
• Code Coverage
• Sophisticated cron monitoring

What GlitchTip has:

• Complete error tracking, with grouping, frequency, first/last seen
• Stack traces of any language supported by Sentry SDKs
• Basic uptime monitoring
• Alerting via webhook, email, and popular integrations
• Minimal issue tracking — assign, resolve, ignore
• Multi-project, multi-team, simple RBAC

For small or medium startup that doesn't use Replay or advanced Profiling, GlitchTip covers what matters with a fraction of the operation. It's the most underestimated case on the shelf.

The self-hosted math, being honest

If your premise for self-hosting is "it'll be free", you'll be disappointed. Real costs of self-hosting Sentry on cheap provider:

Compare:

• Versus SaaS Team (R$130/month): loss of R$300–500/month. Self-hosted at this stage is hobby, not savings.
• Versus SaaS Business in medium use (R$850/month): savings of R$220–420/month. Starts to make sense.
• Versus SaaS scale-up (R$2,500/month): savings of R$1,870–2,070/month. There it's worth the effort.

For GlitchTip, the math is different — the server can be half the size (2 GB / 1 vCPU, R$30/month) and maintenance drops to about 1h/month. Honest total: R$150–200/month. There the breakeven point with SaaS Team arrives.

Comparison table — 12 criteria

When to stay on SaaS

Four profiles where paying Sentry every month is the right decision:

Volume below 100 thousand errors/month. The Team plan at US$26/month covers, no add-ons. Self-hosted that size is a hobby project — you spend more time configuring than you save.

Team of 1 to 3 devs without operational capacity. Each hour spent operating Sentry is hour not spent on product. If you haven't yet hired the first platform engineer, pay the SaaS and move on. The line "first hire SRE to run Sentry" isn't strategy, it's distraction.

You use Session Replay and Profiling. They're SaaS-only features — self-hosting still isn't an option. If your debug workflow depends on those two, the discussion ends.

Compliance requires only LGPD, no local data residency. Sentry has European Union datacenter option, in compliance with GDPR and by extension LGPD. If your legal accepts international transfer of anonymized data, the conformity doesn't force self-hosting.

When self-hosting Sentry makes sense

Three conditions — you need at least two to justify the effort:

Volume passed 1 million errors/month. There the SaaS bill starts competing with salary, and the savings pay for the dev's time taking care of the infrastructure.

Compliance demands data on controlled server. Regulated sectors (health, financial, government, child education) frequently have data residency clause that makes SaaS unviable. Self-hosted is the path.

Team has 1+ dev with recurring time to take care. "Recurring time" = at least 4 hours per month explicitly allocated, with named person and backup. If it's "ah, anyone takes care", in three months no one takes care and the system becomes blind spot.

Bonus: you don't need Session Replay or Profiling. Those two stay on SaaS, so self-hosting means giving them up. For many B2B teams with server-side applications, that giving up is trivial. For B2C teams with complex mobile/SPA app, it can be deal-breaker.

When GlitchTip is the best choice of the three

GlitchTip's ideal profile is specific:

• Startup with R$10–50k MRR, team of 2 to 5 engineers.
• Relatively simple applications — B2B SaaS, web app, mobile backend, API.
• Doesn't use Session Replay (or never used, and doesn't miss it).
• Doesn't use Continuous Profiling.
• Wants self-hosted for control and MIT license, but doesn't want to operate 12 containers.
• Already uses the Sentry SDK and doesn't want to rewrite instrumentation.

If three of those four points match your team, GlitchTip probably saves R$500/month versus SaaS Business without costing the operational overhead of Sentry self-hosted. It's the least-discussed and most frequently useful case.

HeroCtl as operational layer

If you decided to self-host (Sentry or GlitchTip), the cluster where it runs matters almost as much as the product choice. Some observations on running error tracking on HeroCtl:

• Job spec with persistent volumes is native to the product — Postgres, ClickHouse, and Kafka have somewhere to write data without losing anything in a rolling deploy.
• Managed backup is available on the Business plan, covering databases running as jobs in the cluster. Postgres + ClickHouse enter together in the same schedule.
• Integrated metrics of HeroCtl itself show CPU/RAM/IO of each Sentry service — you don't need to set up Prometheus externally just to know if ClickHouse is healthy.
• Integrated router with automatic TLS handles sentry.yourcompany.com.br without any additional certificate operator.
• Compact control plane — 200 to 400 MB per server, leaves plenty of resource for real workload (Sentry, in this case).

For 4-cloud-server cluster, this means: 8 GB of RAM available on the server hosting Sentry, metrics and backup coming free from the orchestrator, and zero external operator to configure. The ROI changes — because part of the "honest" cost of self-hosted is exactly the infra the cluster already offers.

FAQ

How much RAM does Sentry self-hosted consume? In small production, 8 GB of RAM is the firm floor — below that, Kafka starts OOM-killing processes under load. Recommended: 12 GB to have slack. ClickHouse and Kafka are the two largest consumers; together they sum half the total memory.

Is GlitchTip compatible with the existing Sentry SDK? Yes. GlitchTip implements the same HTTP endpoint that Sentry receives the events. Changing the URL on Sentry.init({ dsn: 'https://...' }) pointing to your GlitchTip is enough — the SDK doesn't notice the difference. Reverse migration is also trivial. The SDKs covered include JavaScript, Python, Go, Ruby, PHP, Java, .NET, iOS, Android, and React Native.

Can I migrate from SaaS to self-hosted without losing error history? Technically yes, but with caveats. Sentry SaaS offers event export via API, and self-hosted accepts ingestion. In practice, most teams simply don't migrate history — they start from scratch on the new, and keep SaaS read-only for about 90 days to consult old incidents when necessary. Old error history usually has decreasing value; what matters is what happened in the last 4 weeks.

Does Sentry self-hosted have official support? No, at no level. The self-hosted version is "best effort" from the Sentry company — they publish the release, document, but technical support only appears on the SaaS paid plans. The community on GitHub and in the official forum is active, and most common problems have already been resolved there. For exotic problems, you're alone — or hire specialized consulting.

The BSL license — can I use for commercial SaaS?No. Sentry's BSL 1.1 explicitly prohibits offering Sentry as commercial service to third parties. You can use internally without limit, in any company of any size. But if your idea was to include "dedicated error tracking" in your customer's package charging for it, the license blocks. For that case, GlitchTip (MIT) or other open-source MIT alternatives are the path.

How long does setup from scratch take? Sentry self-hosted: 4 to 8 hours for experienced dev, 2 to 3 days for someone learning. GlitchTip: 1 to 2 hours for experienced dev, half a day for beginner. Those numbers cover clean install, working ingestion, basic alert configured, ready TLS. Doesn't include SDK migration (which is trivial) or fine-tuning of alert rules (which takes weeks in any product).

Is ClickHouse really necessary, or does SQLite serve? For Sentry self-hosted: ClickHouse is mandatory. The product uses the analytic database for aggregation queries that Postgres can't handle under real volume. For GlitchTip: the product uses only Postgres, and that's part of why it's dramatically lighter. SQLite doesn't serve for either of the two in production.

Performance impact on the client app? The Sentry SDK (and GlitchTip's, which uses the same SDK) has overhead below 1ms in most cases — captures error locally, sends in background without blocking. In SPAs, the bundle size adds 30–60 KB gzipped depending on integrations. For server-side apps, the overhead is negligible. Performance Monitoring has slightly higher cost (10% sampling is usually the default), but under reasonable configuration stays below 5ms p99.

Closing

The question "Sentry SaaS vs self-hosted" has a different answer at each company stage. For small startup, SaaS always. For scale-up with high volume and competent team, self-hosted saves real money. For middle of the road, GlitchTip is usually the most lucid choice — significant savings, manageable operational complexity, permissive license.

The math is measurable, not philosophical. Before deciding, check three numbers:

1. How many errors/month your application generates today (any error tracking dashboard shows).
2. What's the projected monthly Sentry bill for the next 12 months (multiply predicted traffic by the corresponding plan).
3. How many hours/month your team can allocate to operating infrastructure without product detriment.

If number 1 is above 1 million, number 2 is above R$1,500, and number 3 is above 4 hours — self-hosting is sane financial decision. Otherwise, stay on SaaS and use the saved time to deliver feature.

To run self-hosted (Sentry or GlitchTip) on a cluster that takes care of TLS, backup, and metrics without external operator:

curl -sSL get.heroctl.com/install.sh | sh

Related posts:

• Observability without Datadog: honest stack for Brazilian startup
• Postgres in production: managed vs self-hosted, the real math