Accessibility testing works best as a repeatable part of the build, test, and deploy process rather than a one-time scan. This guide shows how to combine automated web accessibility testing tools with keyboard navigation, focus, semantic HTML, form, contrast, and assistive-technology checks so each release can be reviewed consistently.
Overview
A website accessibility checker can identify useful patterns quickly, but no single tool can determine whether every person can use a page. Automated checks are good at finding some missing labels, invalid attributes, contrast problems, and structural issues. They are less reliable at judging whether a keyboard user can complete a task, whether focus is visible, or whether instructions make sense when read aloud.
A practical audit therefore uses three layers:
- Automated inspection: Run a browser extension, test runner, or CI check against representative pages and components.
- Manual interaction: Use only the keyboard, resize the page, inspect focus order, and complete important workflows.
- Assistive-technology review: Test key journeys with a screen reader or other assistive technology used by your audience when the project permits.
Think of the result as a risk register, not a score. Record the page or component, the user impact, the reproduction steps, the expected behavior, and the owner responsible for fixing it. A repeatable record makes accessibility regressions easier to spot during redesigns and routine releases.
What to track
1. Keyboard accessibility
Start with the most important user journeys: signing in, searching, purchasing, submitting a form, changing account settings, and opening or closing dialogs. Put the mouse aside and use the keyboard alone.
- Can you reach every interactive control with the Tab key?
- Does the focus order follow the visual and logical order of the page?
- Is the focused element clearly visible against its background?
- Can you operate menus, dialogs, tabs, accordions, date pickers, and custom controls?
- Can you escape from overlays and return focus to the control that opened them?
- Are there keyboard traps that prevent movement to the next or previous control?
Track the exact component where the failure occurs. A modal that loses focus and a form whose submit button cannot be reached are different defects, even if they appear on the same page.
2. Focus states and interaction feedback
Do not treat focus styling as optional decoration. A visible focus indicator helps users understand where an action will occur. Check links, buttons, inputs, custom widgets, and controls inside sticky headers or side panels. Test focus against every relevant background, including hover states, selected states, error states, and dark mode.
Also verify that interaction feedback is understandable without relying on color alone. Validation errors, expanded sections, selected tabs, and status messages should have an appropriate text or structural cue.
3. Headings, landmarks, and semantic structure
Inspect the page outline and ask whether it describes the content accurately. A page should normally have a clear primary heading, meaningful subsection headings, and a sensible hierarchy. Avoid choosing heading elements only because of their default font size; use CSS for presentation and HTML for structure.
Check landmarks such as the header, navigation, main content, complementary areas, and footer. Native HTML elements are usually preferable to adding ARIA roles to generic containers. ARIA can improve custom controls, but incorrect roles, states, or properties can make an interface harder to understand. Test the resulting accessibility tree rather than assuming that an attribute has solved the problem.
4. Forms and error handling
For every form, verify that each field has a programmatically associated label and that instructions are available before input is required. Required fields, accepted formats, and constraints should be clear. When validation fails, identify the affected field, explain how to correct it, and make the message available to the relevant user.
Test both inline and summary errors. After submission, determine where focus goes and whether a user can find the first problem without scanning the entire page. Repeat the test with empty fields, invalid formats, long values, duplicate values, and server-side errors.
5. Color contrast and non-color cues
Use a color contrast testing tool for body text, headings, links, placeholders, icons that communicate meaning, borders that define controls, and focus indicators. Test normal, hover, focus, disabled, error, and selected states rather than checking only the default theme.
Contrast results are useful evidence, but they are not the whole visual review. Confirm that links can be identified without color alone, status messages include text or an icon with an accessible name, and charts or diagrams provide an alternative explanation. Record the foreground color, background color, affected component, and state so a fix can be verified later.
6. Automated tool output
Choose a small set of web accessibility testing tools that fits the project. A browser-based scanner is useful during development, a component-level test can catch regressions before integration, and a CI check can prevent known violations from returning. Review each finding manually before creating a ticket: some results require context, and a passing scan does not prove that the page is usable.
| Check | Useful method | What to record |
|---|---|---|
| Keyboard flow | Keyboard-only task walkthrough | Blocked control, focus order, reproduction steps |
| Contrast | Color contrast analyzer and visual review | Colors, component state, affected text or control |
| Semantics | DOM and accessibility-tree inspection | Heading, landmark, role, name, or state issue |
| Forms | Keyboard submission with valid and invalid data | Labels, errors, focus destination, instructions |
| Automation | Browser scan, component test, or CI check | Rule, selector, severity, confirmed user impact |
Cadence and checkpoints
Accessibility is easiest to maintain when checks occur at predictable points in the delivery cycle.
During component development
Test reusable controls before they spread across the application. Review names, roles, keyboard behavior, focus handling, error states, and contrast in each supported theme. Include accessible examples in component documentation so future changes have a reference.
During pull requests
Run automated checks against changed components and pages. Require a short manual note for interactive changes: which keyboard path was tested, whether focus was checked, and whether forms or dynamic content were involved. Keep the check proportionate; a small text change does not need the same review as a new navigation system.
Before release
Run a representative end-to-end audit across desktop and mobile layouts. Cover the highest-value journeys, authenticated and unauthenticated states, error paths, dialogs, menus, and any newly introduced content. Verify the production build because bundling, hydration, redirects, and third-party widgets can change behavior after local testing.
Monthly or quarterly review
Use a recurring review to sample important pages and examine open accessibility defects. Compare the number and severity of confirmed issues with the previous review, but do not use a single score as the quality measure. Recheck shared components, browser support assumptions, testing tools, and assistive-technology workflows when the product changes significantly.
How to interpret changes
A higher automated finding count does not always mean the site became less accessible. A new scanner rule, broader page coverage, or a change in markup can reveal issues that were already present. Conversely, a clean report may simply mean that the tested page did not exercise a difficult interaction.
When results change, compare four variables:
- Coverage: Were the same pages, states, routes, and user journeys tested?
- Tool configuration: Did rules, browser versions, thresholds, or exclusions change?
- Product behavior: Did a component, framework, design token, or third-party integration change?
- User impact: Does the issue block a task, slow it down, provide confusing information, or affect only a low-risk presentation detail?
Prioritize defects that block completion, hide information, trap focus, or affect common workflows. Then address repeated component-level issues before isolated page defects. A fix in a shared button, dialog, or form pattern can remove several findings at once, but confirm that the change did not introduce a new focus or styling problem.
Keep evidence with each ticket: a short video or screenshot when useful, keyboard steps, the relevant HTML or component name, and the expected result. This makes handoff clearer and allows the same test to be repeated after the fix.
When to revisit
Revisit this accessibility testing workflow before every significant release and at a regular monthly or quarterly checkpoint. Trigger an extra review when you add a design system component, replace a frontend framework, change navigation, introduce a modal or dynamic form, alter color tokens, add a third-party widget, or receive a report from a user.
Use this pre-release checklist:
- Run automated scans on representative pages and review findings manually.
- Complete critical journeys with the keyboard only.
- Confirm visible focus, logical focus order, and reliable escape behavior.
- Inspect headings, landmarks, names, roles, states, and the accessibility tree.
- Test forms, validation errors, status messages, and dynamic updates.
- Check text, controls, focus indicators, and meaningful graphics for sufficient contrast.
- Use a screen reader or other assistive technology for high-risk workflows when available.
- Record unresolved issues, owners, severity, affected routes, and the next review date.
Accessibility testing is most effective when it is attached to ordinary engineering work: component reviews, pull requests, release checks, and regression audits. Keep the checklist close to the repository or quality workflow, update it when the interface changes, and use the same core journeys each time. For related development checks, see the GitHub Actions Workflow Validator Guide for CI troubleshooting and the JSON Formatter and Validator Guide when accessibility test results or API responses need to be inspected safely.