Quick answer
Firebase Crashlytics is free with no event limits, but it's crash reporting only (no two way Jira sync, no anomaly detection, no session replay). This is $0, unlimited volume option.
Sentry free tier (5,000 errors/month) and Bugsnag free tier (7,500 events/month) both include non fatal tracking and basic alerting. These are $0, volume limited options.
GlitchTip (open source, Sentry compatible SDKs) or self hosted Sentry (Docker) give you unlimited events. You pay for compute instead of per event pricing.
Under $30/month, Bugsnag Team (~$22/month) or Sentry Team (~$26/month) are best value. Bugsnag adds stability scoring; Sentry adds two way Jira sync and ownership routing.
For a full feature comparison beyond pricing, see best mobile error tracking tools .
Where Drizz fits in cost equation:
- Drizz is a pre release testing tool, not a production error tracker. It reduces error volume by catching crash inducing regressions before build ships.
- Fewer production errors mean lower Sentry/Bugsnag event consumption, which directly reduces your monthly bill on quota based plans.
- The Jira/Linear integration creates tickets from failed test runs with device context and video prefilled.
Free tier comparison: what do you actually get for $0?
Crashlytics
Crashlytics is completely free with no event caps, no paid tiers, and unlimited team members through Firebase project access. For crash detection on native Android and iOS, it's cheapest option that exists.
Auto symbolication works out of box via Gradle plugin (Android) and Xcode build phase (iOS). You don't need to upload dSYMs manually or configure a CLI tool.
Velocity alerts fire when a crash type affects X% of sessions in 30 minutes, which is cheapest anomaly adjacent feature available on any free plan.
The limitations are real. Jira integration is one way and limited to Bug issue type, so there's no auto resolution or custom field mapping.
Data retention is 90 days, which is better than Sentry and Bugsnag free tiers but still finite. There's no session replay, no non fatal error workflow, and no two way ticketing integration.
A checklist on r/FlutterDev of features you need before releasing any app puts crash reporting at top but notes that Crashlytics covers detection layer without covering resolution workflow. The operational gap is triage automation, not crash detection.
Crashlytics also reports hybrid framework errors (React Native JavaScript freezes, Flutter Dart exceptions) as generic native crashes without clear cross platform stack traces. If you're building cross platform, this limitation costs real debugging time.
When Crashlytics is enough: solo developers, small teams on native Android/iOS, apps under 50K DAU where crash volume is low and manual Jira ticket creation is manageable.
When you outgrow it: when your team has more than one workflow (QA + dev both triaging), when you need automated regression testing results linked to crash data, or when Jira auto creation and two way sync become necessary.
Sentry
Sentry has three pricing tiers that matter for mobile: free (Developer), Team ($26/month per seat), and Business (~$80/month per seat). Each tier unlocks specific capabilities, and gaps between them are where teams get surprised.
Sentry free tier
5,000 errors/month, 1 team member, 30 day data retention. Basic Jira integration without custom field mapping or ownership routing.
No session replay. No anomaly detection.
An indie dev team on r/webdev noted that even Team plan's 50 session replays fill up almost instantly on a mobile app with real traffic. On free tier, you get zero replays, and 5,000 error cap means a single bad deploy or client side rendering loop can exhaust your monthly allocation in minutes.
The free tier works for a solo developer on a small app. The moment a second person needs dashboard access or error volume exceeds 5K/month, you're on Team.
Sentry Team ($26/month per seat)
Adds team seats, two way Jira sync, ownership routing via codeowners, suspect commits, and 90 day data retention. The Team plan bumps error cap from 5K to 50K errors/month.
This is where most mobile teams land. Ownership routing means crash alerts go to developer who owns file that crashed, not to a shared channel.
Suspect commits link crash to specific commit that introduced it.
The per seat pricing is hidden cost here. A 10 person engineering team on Sentry Team is $260/month, not $26/month.
If only 3 people need dashboard access, keep seat count to 3.
Sentry Business (~$80/month per seat)
Adds ML based anomaly detection and session replay. If your traffic is predictable, Team plan's basic alerting may be sufficient.
If your traffic is seasonal or spiky (flash sales, media launches), ML based detection catches unusual patterns that fixed threshold alerts miss.
Sentry hidden costs
SREs on r/sre who moved to self hosted Sentry describe surprise overage bills from unfiltered error loops or unsampled transaction volumes. The cost savings from self hosting were real, but so was infrastructure maintenance overhead.
Quota spikes from bad releases can consume your monthly allocation in hours. Configure spike protection in billing settings and set SDK level sampling (tracesSampleRate at 0.1 instead of 1.0) before a bad deploy happens, not after.
Bots scanning for vulnerabilities (/phpMyAdmin, /wp admin) trigger server side errors that Sentry captures. Without inbound filters (drop events by IP range or error message), bots eat your quota overnight.
A WAF (Cloudflare, AWS WAF) blocking scanners upstream also reduces event volume.
Bugsnag
Bugsnag has a free tier (7,500 events/month, 1 member, 7 day retention) and a Team plan (~$22/month per seat). The free tier is slightly more generous than Sentry free on event volume but significantly worse on data retention.
7 day retention is critical limitation. If a crash is reported on Monday and developer starts investigating following Monday, crash data is gone.
Sentry free retains for 30 days; Crashlytics retains for 90. Short retention forces teams into a reactive pattern: investigate immediately or lose data.
Bugsnag's free tier also excludes Jira integration entirely. If your triage workflow depends on Jira tickets, you're paying for Team on day one.
Bugsnag Team (~$22/month per seat) adds team seats, Jira two way sync, and stability scoring (crash free session percentage per release). Stability scoring is Bugsnag's strongest differentiator at this price: it tells you whether version 3.2.1 is safer than 3.2.0 in a single number.
Sentry Team offers ownership routing and suspect commits instead.
Per seat pricing applies same way as Sentry. A 10 person team on Bugsnag Team is $220/month.
If your primary need is release stability tracking and you don't need ownership routing, Bugsnag Team at $22/seat is cheapest paid option with Jira integration.
What about self hosting to avoid per event pricing?
If commercial cloud billing becomes unmanageable, self hosting removes per event costs entirely.
An SRE team on r/sre tracking millions of events documented their optimization path: aggressive SDK level sampling, offloading routine logs to Grafana Loki, and reserving Sentry exclusively for crashes. That approach kept them on a mid tier plan instead of scaling into enterprise pricing, and when even that wasn't enough, self hosting was next step.
GlitchTip is lightest option. It's open source, uses Sentry compatible SDKs (swap DSN URL and you're done), and runs on a $5-20/month cloud instance via Docker Compose.
Self hosted Sentry gives you full feature set but requires more infrastructure: PostgreSQL, Redis, Kafka, and ClickHouse. Teams typically allocate a dedicated VM or small Kubernetes namespace.
The tradeoff is real: you maintain upgrades, handle storage scaling, and manage backups with no vendor support.
How does pre release testing reduce your error tracking costs?
Every error that Drizz catches in CI never appears in Sentry or Crashlytics. On quota based plans, fewer production errors directly translate to lower monthly bills.
Drizz runs E2E functional tests on real Android and iOS devices as a CI gate. When a test encounters an unhandled exception, Drizz captures device context, failing step, video recording, and PDF report.
The cost math: if shift left testing catches 30% of crash inducing regressions before release, and your app generates 15,000 error events/month on Sentry, you've reduced tracked events by roughly 4,500/month. On Sentry Team pricing, that reduction can keep you within your quota instead of paying for overages.
A thread on r/agile about preventing bugs from reaching production converges on same conclusion: automated integration tests on critical user flows in CI, combined with staged rollouts, catches regressions that generate largest error spikes. The teams that invest in pre release gates spend less on production monitoring because fewer errors make it through.
Choose by budget
FAQ
What is cheapest mobile error tracking tool?
Firebase Crashlytics is free with no event limits, making it cheapest option for crash reporting on native Android and iOS. For non fatal error tracking with a free tier, Bugsnag (7,500 events/month) and Sentry (5,000 errors/month) are next cheapest options.
Is Sentry free for mobile apps?
Sentry has a free tier with 5,000 errors/month, 1 team member, and 30 day data retention. A small app under ~10K DAU with a normal error rate fits comfortably; larger apps typically outgrow it within first month.
What are hidden costs of free error tracking tools?
Data retention limits (7 days on Bugsnag free, 30 days on Sentry free), single team member caps, missing Jira integration on Bugsnag free, no anomaly detection or session replay, and quota spikes from bad releases or bot traffic on Sentry. The largest hidden cost is engineering time spent manually triaging crashes that a paid plan would auto route.
When should I upgrade from Crashlytics to a paid tool?
When you need two way Jira sync, team wide dashboard access, non fatal error workflow, or anomaly detection. Crashlytics covers crash detection well; it doesn't cover triage automation.
Can I self host error tracking to avoid per event pricing?
GlitchTip is open source and Sentry SDK compatible, deployable via Docker Compose for $5-20/month in cloud compute. Self hosted Sentry requires PostgreSQL, Redis, Kafka, and ClickHouse, so it demands more resources but includes full feature set.
How do I prevent Sentry quota spikes?
Configure inbound filters to drop events from bot IPs and irrelevant error messages, set SDK level sampling (tracesSampleRate at 0.1 instead of 1.0), and enable spike protection in billing settings to cap overages. A WAF (Cloudflare, AWS WAF) blocking scanners upstream also reduces event volume.
What's most affordable error tracking tool with Jira integration?
Bugsnag Team at ~$22/month per seat is cheapest paid option with two way Jira sync. Sentry Team at ~$26/month per seat adds ownership based auto assignment and suspect commits on top of two way sync.
How does pre release testing reduce error tracking costs?
Errors caught by E2E tests on real devices in CI never reach production monitoring. On quota based plans like Sentry, fewer production errors mean lower monthly event consumption, keeping you within your allocation or reducing overage charges.
