A reliable accessibility audit combines automated scanners with keyboard, visual, screen-reader, and code-level checks. This reusable workflow helps frontend teams, QA testers, and content editors find WCAG issues, prioritize practical fixes, record evidence, and verify that regressions do not return.
Overview
Web accessibility testing tools are useful for finding defects, but no single scanner can determine whether an entire website is accessible. Automated tools can identify many detectable problems, such as missing alternative text, invalid ARIA relationships, insufficient color contrast, and certain form-label issues. They generally cannot judge whether instructions are understandable, whether a custom widget behaves naturally with a keyboard, or whether a screen-reader user can complete a complex task.
Use a layered website accessibility audit instead. Start with automated testing to establish a repeatable baseline, then test representative pages and user journeys manually. Treat the result as an engineering backlog rather than a one-time score. Each finding should identify the affected component or content pattern, the user impact, the relevant WCAG success criterion where applicable, the recommended fix, and the evidence needed to verify it.
A practical toolset usually includes an automated browser audit or CI scanner, a browser accessibility extension, built-in browser developer tools, a color-contrast checker, keyboard-only testing, and at least one screen reader available to the team. The specific products may change, so focus on the capabilities and the workflow rather than on a permanent tool ranking.
For context, accessibility testing can sit alongside other release checks. A browser compatibility testing workflow helps cover rendering differences, while a Lighthouse performance audit workflow addresses performance concerns that are separate from, but often tested alongside, accessibility.
Checklist by scenario
1. Establish an automated baseline
- Select a representative page set: the home page, navigation and search, a content template, a form, an account or checkout flow, an error page, and any frequently used application view.
- Run an automated accessibility scanner against both authenticated and public areas where relevant.
- Record the page URL, viewport, test date, scanner version or configuration, and the affected selector or component.
- Group duplicate findings by underlying cause. One missing shared label may create many page-level reports but should normally be fixed at the component source.
- Use automated results to find candidates for review, not as proof that a page passes every accessibility requirement.
Browser extensions are useful during development because they provide quick feedback on the current page and often expose the element, rule, and likely location of a problem. CI-based scanning is more useful for regression detection. Whichever approach you choose, keep the configuration consistent enough that changes between runs can be interpreted.
2. Test keyboard access
Keyboard accessibility testing reveals problems that a scanner may not understand. Disconnect or avoid the mouse and complete key tasks using the keyboard. Use Tab and Shift+Tab to move through controls, Enter or Space where appropriate, and arrow keys for composite controls such as menus, tabs, listboxes, and date pickers.
- Can every interactive control receive focus?
- Is the focus order logical and consistent with the visual and reading order?
- Is the focused element visibly identifiable against its surroundings?
- Can users open, operate, and close menus, dialogs, popovers, carousels, and custom widgets?
- When a dialog closes, does focus return to a sensible control?
- Can users reach content that appears after a dynamic update?
- Is there a way to bypass repeated navigation, such as a skip link or an equivalent mechanism?
When a keyboard test fails, capture the exact sequence that exposes the problem. “Modal inaccessible” is less useful than “after opening the help dialog, focus remains behind the overlay and the Escape key does not close it.”
3. Review screen-reader behavior
Screen-reader checks should focus on tasks, not only isolated elements. Choose the screen reader and browser combination used by your team, then document the pairing because output and interaction patterns can vary.
- Navigate by headings, landmarks, links, and form controls. Do these structures communicate the page’s purpose?
- Confirm that images have useful alternatives when they convey information, and are ignored when they are purely decorative.
- Check that link and button names describe their action or destination without relying on surrounding visual context.
- Enter invalid form data. Is the error announced, associated with the right field, and still available after navigation?
- Trigger dynamic content such as validation messages, loading states, and status updates. Is the change communicated without forcing users to search the page?
- Test custom controls for an accurate role, name, state, and value. Avoid adding ARIA when native HTML already provides the needed behavior.
Screen readers are not interchangeable with automated scanners. They provide a realistic interaction check, but they also require practice and should be used with semantic inspection and keyboard testing.
4. Check color, zoom, and visual presentation
Use a color-contrast tool to inspect body text, controls, placeholder text where it communicates information, icons that function as controls, and meaningful text over images or gradients. Recheck states such as hover, focus, disabled, selected, and error rather than testing only the default appearance.
- Zoom the page and check that content remains readable and usable without unexpected overlap or clipped controls.
- Increase text spacing or test a user stylesheet where practical to expose rigid layouts.
- Do not communicate meaning through color alone. Pair color with text, an icon, a pattern, or another visible distinction.
- Check that focus indicators remain visible on light, dark, image, and high-contrast backgrounds.
- Verify that responsive layouts preserve reading order and do not hide essential content at smaller widths.
5. Inspect markup and component behavior
When a finding reaches development, inspect the HTML and JavaScript rather than patching only the visible symptom. Prefer native elements: a real <button> generally provides more reliable semantics and keyboard behavior than a clickable <div>. Associate every form control with a clear label, use headings in a meaningful hierarchy, and ensure that client-side rendering does not remove names, states, or relationships.
For API-driven interfaces, include accessibility states in component and contract tests. If a response controls an error message, loading announcement, or empty state, verify that the frontend renders it with the correct relationship and timing. A structured validation process, such as the one described in this JSON Schema validation guide, can help catch unexpected payload changes before they affect accessible UI behavior.
What to double-check
Prioritization should reflect user impact and reach, not simply the number of automated findings. A useful triage record includes:
- Impact: Does the issue block a task, make information difficult to understand, or create an inconvenience?
- Reach: Does it affect a shared component, a key journey, a single template, or one piece of content?
- Reproducibility: Can another tester follow the same steps and observe the issue?
- Ownership: Is the fix in a component, page template, content entry, design token, or test setup?
- Evidence: Do you have a URL, screenshot or recording where appropriate, DOM location, steps, and expected behavior?
Before closing a finding, compare the result with the intended user task. A contrast correction may solve one issue while a focus-style change introduces another. A new ARIA attribute may make a scanner quiet but still leave the control unusable. Re-run the original steps with the same browser, viewport, assistive technology, and account state whenever possible.
Keep an accessibility regression set for shared components. Include navigation, dialogs, tabs, accordions, form validation, tables, media controls, and any custom widget used repeatedly. Test both the default state and meaningful states such as loading, empty, error, expanded, selected, and disabled.
Common mistakes
- Relying on one score: A score is a useful signal, not a complete WCAG audit. Manual checks remain necessary.
- Scanning only the home page: Templates, logged-in areas, forms, and error states often contain different accessibility risks.
- Testing only a static screenshot: Menus, dialogs, validation, focus movement, and dynamic updates require interaction.
- Fixing duplicate reports one page at a time: Trace repeated findings to the shared component or design system.
- Ignoring content ownership: Heading structure, link text, alternative text, and table markup may need an editor’s correction rather than a code change.
- Using ARIA as a substitute for semantics: Start with native HTML and add ARIA only when the behavior and state are understood.
- Closing issues without evidence: Record what changed and how it was verified so a later release can reproduce the check.
- Testing only after launch: Add component-level checks and keyboard scenarios during development, when fixes are less expensive to coordinate.
When to revisit
Run the full workflow before a major redesign, after a navigation or design-system change, when a new application flow launches, and after substantial changes to forms, authentication, payments, or content templates. Run a smaller regression set for each release that changes shared components or interaction patterns.
Review the toolchain at least every six months, and sooner when browsers, assistive technologies, testing frameworks, or relevant WCAG guidance change. Recheck scanner rules and configuration rather than assuming an updated extension or CI package behaves exactly like the previous version. Refresh saved screenshots, sample findings, and internal instructions annually so they match the current interface.
To make the process repeatable, finish each audit with three short records: the pages and journeys tested, the prioritized issues with owners and evidence, and the regression checks added for future releases. Before the next deployment, confirm that critical tasks work with a keyboard, that focus and announcements behave as expected, that contrast and zoom checks were performed, and that automated results were reviewed rather than blindly accepted. This turns accessibility testing from a one-time inspection into a practical part of web development quality assurance.