JavaScript Error Rate Benchmarks 2027: What Normal Actually Looks Like
Median JS error rate: 0.4% of sessions. 90th percentile: 2.8%. Sourced benchmarks so you can finally answer 'is our error rate bad?'
The Slack ping came in at 4:47 PM on a Thursday. Product manager asking a question I'd somehow never been asked directly in eleven years of SRE work: "Is our JavaScript error rate bad? We're at 0.6% of sessions with errors. Should I be worried?"
I started typing "that's actually pretty good" — then stopped. Was it good? I'd been tracking error rates for a decade, but I couldn't point to a single authoritative benchmark that answered "what's normal?" Embarrassing, honestly. The numbers I'd seen were all over the map. Sentry's annual report said one thing. Our internal data suggested another. A Reddit thread claimed 2% was acceptable. A blog post from 2019 said anything above 0.1% was a crisis.
So I dug in. Pulled every public source I could find. Cross-referenced the vendor reports (skeptically — they're marketing documents). Talked to SRE friends at other companies. And built the benchmark I wished existed.
This post is that benchmark. If you've ever stared at your error tracking dashboard wondering "is this bad?" — here's the data.
Methodology: Where These Numbers Come From
Sources: Sentry's 2026 State of Errors report (8.2B sessions across 34,000 apps), Rollbar's 2026 JavaScript Ecosystem report (12,000 production apps), Bugsnag's 2026 Stability Index, Raygun's Q1 2026 Performance Digest, CNCF 2026 End User Survey (3,100 respondents). Published between October 2025 and July 2026.
Important caveats: vendor datasets skew toward companies already using error tracking tools — the real-world distribution probably has a longer tail of unmeasured chaos. Sample sizes favor English-speaking markets and tech companies. "Error" definitions vary slightly between vendors (some include console warnings, most don't). I've normalized where possible.
When vendors disagreed, I weighted Sentry's numbers most heavily — they have the largest public dataset and the most transparent methodology.
The Headline Number: 0.4% Median Error Rate
The median JavaScript error rate across production web applications is 0.4% of sessions. That means one in every 250 user sessions encounters at least one unhandled JavaScript error.
But medians hide distribution. Here's the full picture:
| Percentile | Error Rate (% of sessions) |
|---|---|
| Top 5% | Below 0.08% |
| Top 10% | Below 0.15% |
| Top 25% | Below 0.25% |
| Median (50%) | 0.4% |
| Bottom 25% | Above 1.2% |
| Bottom 10% | Above 2.8% |
| Bottom 5% | Above 4.6% |
That variance is massive. Top 5% run thirty times cleaner than the bottom 5%. Not a tooling difference. A culture gap. Teams at 0.08% treat errors as bugs to fix immediately. Teams at 4.6%? They stopped reading their error logs months ago.
If your error rate is under 0.4%, you're better than half the web. Under 0.25%, you're top quartile. Under 0.15%, you're legitimately impressive. Over 1.2%? You've got work to do.
(For context on the broader error landscape, our error tracking dashboard covers MTTR, resolution rates, and cost modeling in real-time.)
Framework-Specific Benchmarks
Not all JavaScript is created equal. Framework choice correlates with error rates — though causation is tricky to untangle.
From Rollbar's 2026 JavaScript Ecosystem report (12,000 production apps):
| Framework | Median Error Rate | 75th Percentile |
|---|---|---|
| Next.js | 0.31% | 0.89% |
| Nuxt 3 | 0.35% | 0.94% |
| React (CRA/Vite) | 0.38% | 1.1% |
| Vue 3 | 0.41% | 1.2% |
| SvelteKit | 0.43% | 1.0% |
| Angular 17+ | 0.52% | 1.4% |
| Vanilla JS | 0.67% | 1.9% |
The meta-framework advantage is real. Next.js and Nuxt apps run cleaner — probably because SSR means less JavaScript running in the browser. Fewer opportunities for things to break. (Though I'll admit I expected a bigger gap. Frameworks get too much credit sometimes.)
Angular's higher rate surprised me until I looked at the enterprise angle — Angular apps tend to be older, larger, and running on IE11-era codebases that accumulated technical debt. The framework itself isn't the problem. The baggage is.
Vanilla JavaScript's 0.67% median makes sense too. No framework guardrails, no built-in error boundaries, no standardized patterns. More rope to hang yourself with.
One thing the data doesn't show: TypeScript vs. JavaScript. Vendors don't track this directly, but anecdotally, TypeScript codebases run cleaner. The type system catches whole categories of errors at build time. I'd estimate a 20-30% reduction, but I can't prove it. (I've been wrong about TypeScript benefits before. Take it with salt.)
The Third-Party Script Problem
Here's a stat that should make you angry: 34% of JavaScript errors in production come from third-party scripts.
Sentry's breakdown:
| Source | % of Total Errors |
|---|---|
| First-party application code | 66% |
| Ad networks (Google Ads, Facebook Pixel, etc.) | 14% |
| Analytics scripts (excluding Sentry itself) | 8% |
| Chat widgets (Intercom, Drift, Zendesk) | 6% |
| Payment integrations (Stripe, PayPal embeds) | 6% |
You're inheriting someone else's bugs. That ad network script marketing insists on? Throwing Cannot read property 'push' of undefined in 0.3% of sessions. The chat widget customer success loves? Racing with your bundle loader, failing on slow connections. Not your code. Still your problem.
I've had this argument with marketing teams at three different companies. "But we need the Facebook Pixel!" Sure. But you're also paying for its errors in user experience and engineering time. At minimum, wrap third-party scripts in try-catch or load them in iframes. Better yet — audit your tags quarterly and kill the ones nobody's looking at.
Teams with strict Content Security Policies report 40% fewer third-party errors. Not because CSP prevents errors, but because the policy forces you to audit what scripts you're actually loading. The discipline matters more than the mechanism.
(If third-party outages are your concern, JustAnalytics' uptime monitoring tracks Stripe, AWS, and other critical dependencies automatically.)
Error Volume: 23 Unique Errors Per Day Median
Beyond rates, raw volume matters for triage capacity.
| Metric | Median | Top Quartile | Bottom Quartile |
|---|---|---|---|
| Unique errors/day | 23 | 8 | 95+ |
| Total error events/day | 890 | 280 | 4,200+ |
| New errors/week | 7 | 2 | 28+ |
Top-quartile apps see 8 unique errors per day. Manageable. You can triage every one. At 95+ unique errors per day? Nobody's triaging anything. You're just watching the dashboard scroll, feeling vaguely guilty about it.
The "new errors per week" metric is underrated. If you're introducing 28+ new errors weekly, your release process has a quality problem. You're shipping bugs faster than you're fixing them. Top-quartile teams introduce 2 new errors per week or fewer — and most of those get caught and fixed before the next deploy.
For teams drowning in noise, JustAnalytics' AI-powered anomaly detection handles deduplication and fingerprinting automatically. It won't reduce your actual errors, but it'll surface the signal from the noise.
Industry Breakdown: Finance Runs Cleanest
Error rates vary by vertical. Some industries just care more.
| Industry | Median Error Rate | Notes |
|---|---|---|
| Fintech/Banking | 0.28% | Regulatory pressure drives quality |
| Healthcare SaaS | 0.34% | HIPAA compliance = stricter testing |
| Developer Tools | 0.36% | Engineers as users = less tolerance |
| E-commerce | 0.45% | Checkout errors = lost revenue |
| B2B SaaS | 0.48% | Varies wildly by company stage |
| Media/Content | 0.62% | Ad-heavy pages, lots of third-party |
| Gaming | 0.71% | Complex client-side, many devices |
Fintech's 0.28% median is impressive. When a JavaScript error means a failed payment or a compliance violation, teams prioritize accordingly. Regulatory pressure is annoying — I've sat through enough SOC 2 audits to know — but it produces results.
Gaming's 0.71% makes sense when you consider the surface area: complex WebGL rendering, real-time state synchronization, device fragmentation across thousands of screen sizes. More moving parts means more breakage.
The e-commerce caveat: their 0.45% median hides a bimodal distribution. Checkout flows run at 0.2% or lower (errors there cost money directly). Marketing pages and product listings run at 0.6-0.8% (less instrumented, less prioritized). If you're only measuring checkout, your numbers look great. If you're measuring the whole site, less so.
For e-commerce teams specifically, session replay lets you watch checkout errors happen in real-time — pixel-perfect DOM recording with privacy masking built in.
The Source Map Gap
Quick tangent on measurement quality, because this one genuinely makes me want to throw my laptop: 39% of JavaScript applications still don't have working source maps in production.
From Sentry's dataset:
| Status | % of Apps |
|---|---|
| Source maps working correctly | 61% |
| Source maps configured but broken | 17% |
| No source maps | 22% |
If you're in that 39%, your error rate numbers are probably understated. Why? Because minified errors are harder to deduplicate. main.js:1:45032 might be the same error as main.js:1:45089 — but without source maps, your tool can't tell. They show up as two separate issues.
Fix your source maps before benchmarking. Seriously. Otherwise you're comparing your undercount to everyone else's accurate count. I've seen teams celebrate "great" error rates that were actually just broken instrumentation.
(JustAnalytics handles source map upload automatically via CLI or CI integration — one less thing to break.)
Browser-Specific Error Rates
Not all browsers break equally.
| Browser | Error Rate Multiplier vs. Chrome |
|---|---|
| Chrome/Chromium | 1.0x (baseline) |
| Firefox | 1.1x |
| Safari | 1.4x |
| Edge | 1.0x |
| Samsung Internet | 1.6x |
| UC Browser | 2.1x |
| IE11 (yes, still) | 3.8x |
Safari's 1.4x multiplier is the one that matters for most teams. Webkit has its own JavaScript quirks — different handling of optional chaining in older versions, different memory management, different behavior on low-power mode. If you're not testing on real Safari devices, you're missing bugs.
IE11's 3.8x multiplier should convince anyone still supporting it to stop. That 1% of traffic is generating 4% of your errors. Drop it. (Unless you're selling to government agencies. Then, my condolences. I spent six months of my life on IE11 compatibility patches once. Six months I'll never get back.)
Mobile Safari deserves special mention. iOS Safari on low-power mode aggressively throttles JavaScript. Code that runs fine on desktop Safari throws timeout errors on iPhone. If your mobile error rate is suspiciously high, check low-power mode scenarios.
For teams struggling with Safari measurement issues, JustAnalytics' cookieless tracking sidesteps ITP entirely — no cookies means no cookie blocking.
What "Good" Looks Like in 2027
Okay, enough tables. Here's the framework I actually use:
Error rate (% of sessions with unhandled errors):
- Elite: Below 0.15%
- Good: 0.15% - 0.4%
- Acceptable: 0.4% - 1.0%
- Concerning: 1.0% - 2.0%
- Crisis: Above 2.0%
Daily unique errors:
- Elite: Under 5
- Good: 5 - 15
- Acceptable: 15 - 40
- Concerning: 40 - 100
- Crisis: Above 100
New errors per release:
- Elite: Under 1
- Good: 1 - 3
- Acceptable: 3 - 8
- Concerning: 8 - 20
- Crisis: Above 20
If you're "Good" on all three metrics, you're doing better than most of the web. Don't let perfect be the enemy of shipped. "Acceptable" is fine for most teams, honestly. I've been at companies in "Acceptable" that shipped great products. But if you're in "Concerning" or "Crisis" territory, you've got a quality problem that's costing you users — and probably your on-call's sanity. Been there. It's not fun.
The Cost Translation
Nobody asked me about cost, but here it is anyway — because this is how I get budget approved.
At 0.4% error rate (median) with 100K monthly sessions:
- 400 sessions affected per month
- Estimated 2-3% of those users churn from the error = 8-12 users
- At $50 LTV per user = $400-600 monthly revenue impact
- Plus engineering time debugging: ~4 hours/month at $150/hr = $600
- Total: roughly $1,000-1,200/month in direct costs
At 2.0% error rate (bottom quartile):
- 2,000 sessions affected per month
- 40-60 users churning = $2,000-3,000 revenue impact
- Engineering time: ~12 hours/month = $1,800
- Total: $3,800-4,800/month
The difference between median and bottom-quartile is $30,000-40,000 annually for a 100K-session app. Scale that up. At 1M sessions, it's $300,000-400,000. That's a headcount. That's a product feature. That's real.
This math is intentionally conservative. It doesn't include support ticket costs, brand reputation damage, or the opportunity cost of engineers debugging instead of building. The actual number is higher.
For teams tracking the broader observability spend, JustBrowser covers browser-level performance monitoring that complements error tracking.
Frequently Asked Questions
What is a normal JavaScript error rate for web applications?
The median JavaScript error rate for production web applications is 0.4% of sessions experiencing at least one unhandled error, based on Sentry's 2026 State of Errors report analyzing 8.2 billion sessions. Top-performing applications maintain error rates below 0.15%, while the bottom quartile exceeds 1.2%. These figures exclude handled exceptions and expected validation errors — they represent actual unhandled JavaScript errors that disrupt user experience.
How do JavaScript error rates vary by framework?
Framework-specific error rates vary significantly. React applications average 0.38% error rate, Vue sits at 0.41%, Angular at 0.52%, and vanilla JavaScript at 0.67%. Next.js and Nuxt applications trend lower at 0.31% and 0.35% respectively, likely due to SSR reducing client-side surface area. These figures come from Rollbar's 2026 JavaScript Ecosystem report covering 12,000 production applications.
What percentage of JavaScript errors are caused by third-party scripts?
Third-party scripts cause 34% of JavaScript errors in production, according to Sentry's dataset. Ad networks contribute 14%, analytics scripts 8%, chat widgets 6%, and payment integrations 6%. First-party application code accounts for the remaining 66%. Teams with strict Content Security Policies report 40% fewer third-party errors on average.
How many unhandled JavaScript errors per day is normal?
The median production application logs 23 unique unhandled JavaScript errors per day, generating approximately 890 total error events. Top-quartile applications see 8 unique errors per day or fewer. Bottom-quartile applications exceed 95 unique errors per day — at which point most teams experience alert fatigue and stop triaging effectively.
Try JustAnalytics
All-in-one observability in one under-5KB script: cookieless analytics + error tracking + APM + session replay + uptime + structured logs. Replaces GA4 + Sentry + Datadog + Pingdom + LogRocket. Free tier (100K events/mo), Pro $49/month ($39 annual).
Author at JustAnalytics.