Web accessibility testing is most effective when it is part of the normal frontend workflow rather than a final audit. This guide provides a repeatable way to check keyboard navigation, focus behavior, semantic HTML, ARIA states, color contrast, forms, headings, images, and screen-reader basics before release and during later UI changes.
Overview
An accessibility checker for websites can identify useful patterns quickly, but automated results are only one part of the review. A page may pass an automated scan and still be difficult to use with a keyboard, confusing when read aloud, or unclear when a form returns an error. A practical test combines automated checks with manual interaction and a small number of assistive-technology spot checks.
Use this workflow for a new page, a redesigned flow, a shared component, or a release candidate. Test representative states rather than only the default view: empty forms, validation errors, loading states, open menus, dialogs, expanded accordions, logged-out screens, and content that changes after an API request. Accessibility problems often appear when the interface changes state, not when it first loads.
For each issue, record the page or component, the user impact, reproduction steps, expected behavior, actual behavior, and a suggested fix. This turns a general WCAG checklist into a useful engineering backlog.
What to track
1. Keyboard navigation and focus
Start with a real keyboard-only pass. Put the pointer aside and use Tab, Shift+Tab, Enter, Space, and the arrow keys where appropriate.
- Every interactive control can receive focus without requiring a mouse.
- The focus order follows the visual and logical reading order.
- Focus is clearly visible against the surrounding background.
- Menus, dialogs, accordions, tabs, and custom controls respond to expected keys.
- A user can reach and operate controls near the bottom of the page.
- Opening a dialog moves focus into it, and closing it returns focus to a sensible trigger.
- No component traps focus unexpectedly or allows focus to disappear behind an overlay.
Pay particular attention to CSS changes that remove outlines, apply low-contrast focus styles, or place an element visually in one location while leaving it elsewhere in the document order. A visible focus ring is not decoration; it is the keyboard user’s position indicator.
2. Semantic structure and ARIA
Inspect the HTML before adding ARIA. Native elements such as <button>, <label>, <nav>, and <main> usually provide behavior and meaning that a styled <div> does not. Confirm that headings describe the page structure and are not chosen only for their visual size.
For custom widgets, check the complete interaction model rather than only the presence of an attribute. A disclosure control, for example, should expose its expanded state, identify the content it controls, and update that state when activated. Tabs should communicate the selected tab and its associated panel. A dialog should have an accessible name and an appropriate focus strategy.
Use browser developer tools or an accessibility tree inspector to compare the intended name, role, and state with what the browser exposes. ARIA can repair a specific semantic gap, but incorrect or stale ARIA can make a working control harder to understand.
3. Color contrast and non-color cues
Run color contrast testing on body text, labels, placeholders, links, buttons, borders that convey meaning, and focus indicators. Check normal, hover, focus, disabled, error, and selected states. Do not assess only the design token values; inspect the rendered colors after opacity, overlays, gradients, and background images are applied.
Color should not be the only way to communicate status. Pair error colors with text or an icon and a useful message. Distinguish required fields with text or a programmatic indication rather than relying on a color change alone. Check charts, badges, syntax highlighting, and selected navigation items for the same issue.
4. Forms and validation
Test forms from an empty state through successful submission and failure. Every input needs a persistent, programmatically associated label. Placeholder text can provide an example, but it should not replace the label. Group related controls, such as radio buttons or checkboxes, with a meaningful legend or equivalent structure.
When validation fails, make the problem easy to find and fix. The message should identify the field, explain what is wrong, and suggest the required format when useful. Confirm that the field remains associated with its message and that the error is announced or otherwise discoverable without forcing a user to scan the entire page. Test long values, missing values, invalid formats, and server-side errors.
5. Headings, landmarks, links, and images
Review the page as an outline. There should be one clear page purpose, a sensible heading hierarchy, and landmarks that help users move between navigation, main content, complementary content, and the footer. A heading should describe the section that follows; it should not be used merely to make text look larger.
Link text should make sense in context and should distinguish destinations when several links appear together. Avoid repeated vague labels such as “click here” when a more specific label is possible. Images need alternative text based on their purpose: informative images need a concise description, decorative images can be ignored by assistive technology, and complex visuals may need a nearby explanation.
6. Screen-reader spot checks
A full assistive-technology test matrix may belong in a dedicated QA plan, but a short screen-reader pass is valuable. Move through headings, landmarks, links, form controls, buttons, dialogs, and dynamic messages. Listen for missing names, duplicated announcements, incorrect states, unexpected reading order, and content that appears visually but is absent from the accessibility tree.
Use the screen reader and browser combination supported by your team or audience, and document the environment with each finding. Treat this as a complement to keyboard navigation testing, not a replacement: some keyboard problems are obvious without speech, while some naming and state problems require an accessibility tree or screen reader.
Automated versus manual checks
| Test area | Automated tools are useful for | Manual testing is needed for |
|---|---|---|
| Structure | Detecting some missing landmarks, duplicate IDs, and invalid patterns | Judging whether the hierarchy and reading order make sense |
| Keyboard use | Highlighting some focus and tabindex risks | Checking every interaction, focus movement, and escape path |
| Contrast | Measuring many text and interface color combinations | Checking overlays, states, non-color cues, and real content |
| Forms | Finding some missing labels and association errors | Verifying instructions, error recovery, announcements, and submission flow |
| ARIA | Flagging invalid attributes or unsupported combinations | Confirming that names, roles, states, and keyboard behavior match |
| Screen readers | Inspecting the accessibility tree | Evaluating how the complete page is experienced when read aloud |
Cadence and checkpoints
Run a lightweight automated scan on every pull request or preview build when the tooling fits your stack. Pair it with manual testing for changed components and user flows. A smaller, repeatable check is more useful than an ambitious review that happens only before a major launch.
Use these checkpoints as a practical cadence:
- During component development: test keyboard behavior, focus styling, semantics, states, and contrast before the component enters the shared library.
- During feature review: test the complete flow, including validation, loading, empty, success, and failure states.
- Before release: run an automated scan on representative pages, then perform keyboard and screen-reader spot checks on the highest-value journeys.
- Monthly or quarterly: sample important pages again, review unresolved defects, and confirm that browser, framework, and assistive-technology changes have not altered behavior.
- After a redesign or CSS refactor: repeat focus, contrast, responsive layout, and reading-order checks even when the underlying content is unchanged.
Keep a small regression set: the site header, primary navigation, sign-in or account flow, a representative form, a modal or menu, and one content-heavy page. Add a component whenever it introduces a new interaction pattern.
How to interpret changes
Not every audit result represents the same level of risk. Prioritize issues that block an essential task, hide important information, prevent keyboard operation, or affect many pages through a shared component. A missing focus indicator in a global navigation component may deserve faster attention than a minor issue on an infrequently used page.
Separate defects from review questions. A missing label is usually a concrete defect; a heading hierarchy may require a content decision. Record both, but give each a clear owner. When a scan reports an issue, reproduce it in the rendered interface before changing code. Automated tools can produce false positives, miss state-specific problems, or identify a symptom rather than the underlying cause.
Look for patterns across releases. A rising number of focus regressions may indicate a component-library or CSS process problem. Repeated contrast failures may point to design tokens that need revision. Forms that work in isolation but fail after an API response may need a shared error-handling pattern. Trend information helps the team improve its workflow instead of repeatedly patching individual pages.
When to revisit
Revisit this workflow whenever a page, component, browser environment, or accessibility requirement changes. At minimum, schedule a monthly or quarterly review for important journeys and a focused check for every meaningful UI release. Refresh the checklist when your framework changes its rendering behavior, your design system introduces new components, or your browser and assistive-technology test set changes.
Before publishing, use this final action list:
- Choose representative pages and states, including errors and dynamic content.
- Run an automated accessibility checker and triage each result manually.
- Complete a keyboard-only pass from the first interactive element to the final action.
- Inspect focus visibility, focus order, dialog behavior, menus, tabs, and custom widgets.
- Check semantic HTML, headings, landmarks, link names, image alternatives, and ARIA states.
- Measure contrast in normal and interactive states, and remove color-only instructions.
- Submit forms with missing, invalid, and unexpected values; verify understandable recovery.
- Perform a short screen-reader and accessibility-tree spot check on the main user journey.
- Record defects with reproduction steps, assign owners, and repeat the affected test after fixes.
Accessibility testing is a recurring quality practice, not a one-time certificate. Keeping the same checkpoints in your frontend workflow makes regressions easier to notice and gives designers, developers, and QA teams a shared way to improve the experience over time.