What does it cost your organization to let an accessibility bug slip through to production?
If you never intend to fix the bug, that cost is low. But if you do, the cost can be substantial.
How do we know? Because we asked. We sat with customers who care deeply about accessibility, and several of them were candid about exactly what they were spending to fix bugs found in production, sharing their numbers with us under NDA. We also asked our own team the same question about our own development process.
The answers varied, of course. But what was consistent was how easily and commonly a bug found in production can cost at least $15,000 to fix. (You may remember this number from our post on false negatives.)
And while $15,000 might sound extreme, rest assured it all adds up once you trace where the costs actually come from. Let’s break it down.
The scenario
To be clear: one developer fixing a line of code in real time won’t come close to $15,000. But a bug found in a live production site – by an end user or an auditor, months after the build shipped – is a very different story.
By that point, fixing it isn’t work for one person. It requires many team members, many steps, and a lot of coordination overhead.
As a first step in going through this, here’s a summary of the resources costs generated at each phase of remediation.
Exhibit 1. Resource Cost Summary, Remediation of Production Accessibility Bug
| Phase | Tasks | Resource Cost |
|---|---|---|
| Triage | Read list, reproduce issues, prioritization meeting with team, etc. | $3,775 |
| Diagnosis | Root cause analysis, decide fix approach and teams involved, etc. | $3,950 |
| Fix | Create new design, check accessibility of design, engineer the design, perform self-tests, etc. | $4,630 |
| Review | Perform functional tests, automated accessibility scans, assistive tech checks, look at adjacent components, etc. | $2,250 |
| Deployment | Merge to production, monitor, close JIRA ticket, update release note, communicate to fix to stakeholders, etc. | $600 |
| Total | $15,205 |
Discussion
When we say “resource cost,” what we mean is we are tallying employee time spent and weighting it by the fully loaded hourly rate1 for each employee’s time.
So another way of asking, “Why so expensive?” is to ask “Why does it take so much time?”
There are several reasons.
Hours multiply by headcount
A one-hour meeting with an accessibility manager, engineer, designer, and product manager is actually four hours of billed time. That’s before anyone has written a line of code or opened a design file. The more people required to align on a fix, the faster the hours compound. This is the single biggest driver of why complicated bugs get expensive: it’s not any one person’s time, it’s the coordination overhead across all parties involved.
Context switching costs time
By the time an audit report or the complaint from an end-user arrives, the team has moved on. The original engineer may be on a different project. The designer who built the component has long forgotten it and is working on something else. Re-entry into old work takes time. Team members must reopen branches, reinstall dependencies, re-learn interaction logic that made sense six months ago and is now forgotten. Even professionals need time to context switch so they can get the fix right.
Complex component problems have a blast radius
A multi-select dropdown component likely isn’t just one instance on one singular page. It’s very likely that the component lives on multiple pages, such as the Search page, the Filter panel, the Settings form, and the Checkout flow. Every fix has to be validated everywhere the component appears. That multiplies QA scope dramatically.
(Manual) accessibility review is complicated
There’s a difference between a fix that looks right and a fix that works across operating systems, browsers, and assistive technologies. Teams have to check if the solution works in NVDA on Firefox, VoiceOver on Safari, and keyboard-only navigation across all those pages. And if something breaks in one instance, it’s back to the drawing board or, at least, back to the conference room for a prioritization debate.
The people in the room are expensive
Accessibility isn’t a solo job. The accessibility manager, product manager, designer, engineer, QA, and sometimes an external subject matter expert (SME) and consultant are all in this process at different points. Each of their hours costs money, and each handoff adds coordination overhead.
It’s important to note that the bug in the scenario above assumes availability of accessibility expertise. The cost for organizations without access to in-house (or out of house) accessibility expertise would be even higher.
First-hand experience at Evinced
Still skeptical? We understand. So, in the interest of transparency, here’s a story from our own backyard.
Not long ago, the Evinced team discovered a multi-select dropdown component with a serious accessibility problem, in production, after the fact. It was complex. It required five weeks of work from a team of four to five people, including our own accessibility specialists, who are very good at what they do.
If you run the math on that, the cost to our team was well over $100,000. So when we say $15,000 is a reasonable number, we mean it.
Consider the scale
Now consider the scale of the problem beyond a single bug.
When new customers come to us for the first time, it is very common for their website to have 10,000 or more critical accessibility issues. Evinced reduces that workload significantly by clustering issues by coding pattern into what we call components. Even so, it’s common for customers to arrive with hundreds of component-level problems. At $15,000 each for 200 components, that could be $3 million of resource cost.
And, sure, not all bugs cost $15,000 – maybe some are $5,000, some are $10,000, and some are $20,000+ to fix. It’s still money that’s already been paid to build those features once. Now the organization has to pay to build them again, accessibly.
To put it frankly, if you pay to do it wrong, you’ll have to pay to do it right.
None of the costs above are the result of negligence or bad engineering. They are the predictable consequence of finding accessibility issues late. You pay a premium to find and fix bugs after context has faded, teams have moved on, and components have spread across your product.
As your organization considers accessibility tooling, it’s natural to ask whether your accessibility budget can afford it. But can you afford not to?
See for yourself
Your company’s numbers may well be different from our estimates. To calculate it precisely, download this Excel model. Plug in your team’s rates and anticipated hours to get an idea of what an accessibility bug found in production could cost your company.
Detailed breakdown of each phase
Triage Phase
| Step | F | H | P | RCR | Total |
|---|---|---|---|---|---|
| Read and triage the audit list to select the item to fix, mapping issues to WCAG criterion or severity level (critical/serious/etc.). | A + PM | 4 | 2 | $150 | $1,200 |
| Reproduce the targeted issue. | Dev/QA | 2 | 1 | $200 | $400 |
| Decided with larger team whether to fix the issue. | J | 2 | 4 | $150 | $1,200 |
| Decide which sprint to fix the issue in. | J | 0.5 | 3 | $150 | $225 |
| Write JIRA ticket for bug to be fixed, with an owner assigned, translating WCAG criteria to practical terms if necessary. | PM/A/QA | 2 | 2 | $150 | $600 |
| Park deferred items somewhere, documented, so the team can return to them. | PM | 1 | 1 | $150 | $150 |
| Total | $3,775 |
Key:
- F – Functions: Accessibility Team (A), Product (PM), Developer (Dev), Designer (Des), QA Engineer (QA), Joint effort (J)
- H – Hours (per person working on the step)
- P – People (number of team members working on the step)
- RCR – Resource Cost Rate
Diagnosis Phase
| Step | F | H | P | RCR | Total |
|---|---|---|---|---|---|
| Perform a root cause analysis. | Dev | 6 | 1 | $200 | $1,200 |
| Document the failure. | Dev | 1 | 1 | $200 | $200 |
| Determine the fix approach. | J | 2 | 4 | $150 | $1,200 |
| Consult ARIA authoring practices. | A | 1 | 1 | $150 | $150 |
| Estimate the effort required. | J | 1 | 4 | $150 | $600 |
| Determine whether Design needs to be involved. | J | 1 | 4 | $150 | $600 |
| Total | $3,950 |
Key:
- F – Functions: Accessibility Team (A), Product (PM), Developer (Dev), Designer (Des), QA Engineer (QA), Joint effort (J)
- H – Hours (per person working on the step)
- P – People (number of team members working on the step)
- RCR – Resource Cost Rate
Fix Phase
| Step | F | H | P | RCR | Total |
|---|---|---|---|---|---|
| Create an alternative design with annotation. | Des | 2 | 1 | $150 | $300 |
| Confirm the new design fits the product requirement and all usages. | Des + PM | 2 | 2 | $150 | $600 |
| Confirm the new design is accessible and do any rework necessary. | Des + A | 1 | 2 | $150 | $300 |
| Design hands off to developer; due to complexity they meet to discuss. | Des + Dev | 1 | 2 | $150 | $300 |
| Engineer the new design. | Dev | 6 | 1 | $200 | $1,200 |
| Test new design with screen reader and keyboard before handoff to Developer. | A | 1 | 1 | $200 | $200 |
| Write automated test for the fix. | Dev | 2 | 1 | $200 | $400 |
| Submit the pull request. | Dev | 0.5 | 1 | $200 | $100 |
| Check that the code has been engineered correctly and is accessible. | A + Dev | 2 | 2 | $150 | $600 |
| Meeting loop allowance. (Note: We see about 35% of cases require an additional meeting cycle to determine the right solution and implement the fix.) | J | 3 | 4 | $150 | $630* |
| Total | $4,630 |
Key:
- F – Functions: Accessibility Team (A), Product (PM), Developer (Dev), Designer (Des), QA Engineer (QA), Joint effort (J)
- H – Hours (per person working on the step)
- P – People (number of team members working on the step)
- RCR – Resource Cost Rate
*This amount ($630) represents a 35% chance of needing a meeting and resolution loop.
Review Phase
| Step | F | H | P | RCR | Total |
|---|---|---|---|---|---|
| QA review, included in end-to-end functional testing. | QA | 3 | 1 | $150 | $450 |
| Automated accessibility scanning. | QA | 1 | 1 | $150 | $150 |
| Assistive technology testing across browsers and multiple assistive technologies. | QA | 1 | 1 | $150 | $150 |
| Confirm automated test exists and is passing (Dev confirms, QA signs off). | QA + Dev | 1 | 2 | $150 | $300 |
| Check adjacent components that they’re working correctly post-fix. | QA | 1 | 1 | $150 | $150 |
| Meeting loop allowance in case something breaks. (Note: We see about 35% of cases require an additional meeting cycle.) | J | 2 | 4 | $150 | $420* |
| Repeat the Review loop until QA is clear. (35% probability of needing a cycle.) | J | 3 | 4 | $150 | $630* |
| Total | $2,250 |
Key:
- F – Functions: Accessibility Team (A), Product (PM), Developer (Dev), Designer (Des), QA Engineer (QA), Joint effort (J)
- H – Hours (per person working on the step)
- P – People (number of team members working on the step)
- RCR – Resource Cost Rate
*These amounts ($420 and $630) represent a 35% chance of needing a meeting and resolution loop.
Deployment Phase
| Step | F | H | P | RCR | Total |
|---|---|---|---|---|---|
| Merge to production and monitor immediate functionality. | J | 1 | 2 | $150 | $300 |
| Perform smoke test to confirm fix is live and the page isn’t broken. | QA | 1 | 1 | $150 | $150 |
| Update release notes to document the fix. | PM | 0.5 | 1 | $150 | $75 |
| Communicate that the fix is live to all stakeholders. | A | 0.5 | 1 | $150 | $75 |
| Total | $600 |
Key:
- F – Functions: Accessibility Team (A), Product (PM), Developer (Dev), Designer (Des), QA Engineer (QA), Joint effort (J)
- H – Hours (per person working on the step)
- P – People (number of team members working on the step)
- RCR – Resource Cost Rate
- The fully loaded hourly rate represents the total cost to the company, not the employee’s take-home pay. For example, an engineer with a fully loaded rate of $200/hour includes salary plus employer payroll taxes, health and retirement benefits, and a share of general and administrative (G&A) costs – the overhead required to support an employee, such as office space, computer hardware, software and IT tools. ↩︎
