Latest / Software Testing with Fexingo: QA, Automation, and Reliable Software Engineering / How Accessibility Testing Prevents Legal and UX Risks
Transcript
- Luna: Lucas, I saw a statistic that over 4,000 website accessibility lawsuits were filed in the US last year. That's a 15% increase from the year before. And a lot of those could have been caught with basic automated testing. Lucas: Yeah, that number keeps climbing. In 2025, we saw more than 4,200 ADA Title III lawsuits targeting digital accessibility. And it's not just mom and pop shops — major retailers, airlines, and even streaming services have been hit. The cost of a single lawsuit can easily run into the hundreds of thousands when you factor in legal fees, remediation, and brand damage. Luna: And the worst part is, most of these violations are what I'd call 'low-hanging fruit' — missing alt text on images, poor color contrast, focus traps in navigation. Things you could catch with a script. Lucas: Exactly. The Web Content Accessibility Guidelines — WCAG 2.1 and now 2.2 — break things into four principles: perceivable, operable, understandable, and robust. Each has specific success criteria at levels A, AA, and AAA. For most businesses, achieving AA compliance is the standard, and it's actually measurable. You can run a tool like Axe or Lighthouse and get a score for each page. Luna: But a score isn't a pass, right? Automated tools only catch about 30 to 40 percent of issues. The rest require manual testing — screen readers, keyboard-only navigation, zoom testing. Lucas: Right. That's the hard part. Automated tests are great for catching things like missing `alt` attributes or insufficient contrast ratios. But they can't tell you if the tab order makes logical sense or if a screen reader announces a live region update that's actually confusing. That takes a human with a JAWS or VoiceOver session. Luna: So how do teams prioritize which flows to test? I imagine you can't manually test every single page in a large app. Lucas: You prioritize by user impact and legal risk. Start with the critical user journeys — login, checkout, search results, account creation. Those are the flows that, if inaccessible, not only block a huge percentage of users but also have the highest likelihood of ending up in a lawsuit. Then layer in the high-traffic pages. After that, you can cycle through the rest on a regular cadence. Luna: And you should integrate those automated checks into the CI/CD pipeline. Every pull request gets scanned, and if a new violation is introduced, the build fails. That's how you prevent regressions. Lucas: Absolutely. And there are some great open-source tools for that — axe-core runs as a Node module, Pa11y can be plugged into your test suite. You can set thresholds: no new critical or serious violations allowed. That way accessibility becomes a backward-looking check as well as a forward-looking design requirement. Luna: I like how you said 'design requirement'. Because a lot of accessibility issues actually originate in design — low-contrast text chosen for brand aesthetics, interactive elements that don't have focus indicators, complex gestures that require fine motor control. If you catch it in the mockup phase, it's free to fix. Lucas: Yes. That's the curb-cut effect in action — the idea that designing for the margins improves the experience for everyone. The ramp at the curb was designed for wheelchairs, but people with strollers, suitcases, or delivery carts use it just as much. Similarly, proper heading structure helps screen reader users navigate, but it also makes the page easier for anyone to skim. Captions help deaf users, but they also help people in noisy environments. Luna: So the return on investment isn't just avoiding lawsuits — it's a better product for all users. And there's a growing body of research showing that accessible sites have better SEO, lower bounce rates, and higher conversion rates. Lucas: Right. Google uses accessibility signals as a ranking factor. Plus, if you have a checkout button with gray text on a white background, it's not just inaccessible to someone with low vision — it's harder for everyone to see. You're literally losing sales. Luna: Let's talk about some concrete examples. I recall a case where a major travel site had a date picker that was completely unusable with a keyboard. You could click it with a mouse, but if you tried to tab through and select dates, the focus got trapped. That's a WCAG 2.1.2 violation — no keyboard trap. And that kind of thing is shockingly common in custom UI components. Lucas: It's because many developers rely on complex JavaScript libraries that don't properly manage focus. The solution is to use native HTML elements where possible — a standard `<select>` is keyboard-accessible out of the box. But if you need a custom control, you have to manually manage `tabindex`, `aria-activedescendant`, and keyboard event listeners. It's doable, but it requires knowledge. Luna: And that's where training comes in. Teams that invest in accessibility training for developers and QA see a measurable reduction in issues over time. It's not just about tools; it's about culture. Lucas: Exactly. And one of the most effective training exercises is to have developers spend an hour using their own product with only a keyboard — no mouse, no touchpad, no touchscreen. Or ask them to navigate using a screen reader like NVDA. It's humbling, and it builds empathy really fast. Luna: I've done that. The first time I tried to book a flight with VoiceOver, I almost threw my phone across the room. But it made me a better tester because I understood the frustration. Lucas: And that empathy translates into better test cases. You start thinking about edge cases like 'what happens when the user is using high contrast mode?' or 'what if they have a screen magnifier?' These are things that often get left out of functional test plans. Luna: So if someone wants to start improving accessibility testing in their organization tomorrow, what's the first step? Lucas: Run an automated scan on your top five pages. Use something like axe DevTools or Lighthouse in Chrome. Get a baseline. Then fix the low-hanging fruit: missing alt text, insufficient color contrast, missing form labels. Those alone will often get you to around 60-70 percent compliance on the automated front. Then start planning the manual tests for the critical flows. Luna: And don't forget to document the exceptions. Sometimes an image is decorative and should have `alt=''`, not descriptive text. Sometimes a design intentionally uses low contrast for legal terms. But you have to document the reasoning so the next person doesn't flag it as a false positive. Lucas: Good point. And that documentation ties back to the broader theme of this show — testing is only as good as the context around it. An accessibility violation without context is just a number. But with the story behind it, you can make smart trade-offs. Luna: Honestly, if today was worth a coffee to you, that's the link — buy me a coffee dot com slash fexingo. Every little bit helps keep this show ad-free and focused on practical content. Lucas: Yeah, and speaking of practical — once you've got your baseline, think about integrating Pa11y-ci into your Git hooks. That way no one can commit code that introduces a new critical accessibility error. It's a small enforcement that pays huge dividends. Luna: And for manual testing, create a checklist based on the top 10 WCAG criteria that are most commonly violated. You can find these lists from the WebAIM million report — they analyze the home pages of the top million sites each year. The top failures are consistently low contrast, missing alt text, missing form labels, empty links, and missing document language. Lucas: So the pattern is clear: accessibility testing isn't a one-time project. It's a continuous practice that, when done right, protects you legally, improves user satisfaction, and even boosts your bottom line. And the tools are getting better every year. Luna: I think the key insight is that accessibility is really quality — it's about making sure everyone can use what you build. And that's the core of what we talk about on this show. Lucas: Exactly. So next time you're writing a test case, ask yourself: does this cover someone who can't use a mouse? Someone who's blind? Someone who's colorblind? If not, you're leaving money — and users — on the table.