Use this repeatable web accessibility testing checklist to evaluate keyboard access, screen-reader behavior, forms, focus management, color, motion, and supporting API states. It combines automated checks with manual testing so accessibility becomes part of release and regression work rather than a one-time audit.
Overview
A website accessibility audit should answer a practical question: can people with different interaction, vision, hearing, cognitive, and motor needs complete the same important tasks as other users? Testing should cover the interface, the content it presents, and the backend states that drive it. An accessible form, for example, can still fail when an API returns an error that is not announced, a session expires without a usable recovery path, or a loading state leaves keyboard users without feedback.
Use WCAG as a reference framework, but do not treat a passing automated scan as proof of accessibility. Automated tools are useful for detecting patterns such as missing labels, invalid ARIA, and some contrast problems. They generally cannot determine whether a heading hierarchy makes sense, whether focus moves logically, or whether a screen-reader user understands a complex workflow.
For each audit, choose two or three representative journeys instead of checking isolated pages only. Examples include signing in, searching and filtering records, submitting a form, reviewing an API-generated result, and handling a failed request. Test the same journeys with a mouse, keyboard, zoom, a screen reader, and a narrow viewport.
What to track
1. Keyboard access and focus
- Move through the complete journey with Tab, Shift+Tab, arrow keys, and the relevant activation keys.
- Confirm that every interactive control is reachable and has a visible focus indicator.
- Check that focus order follows the intended reading and task order, not merely the visual position.
- Open and close menus, dialogs, date pickers, and custom controls without a pointer.
- When a dialog opens, move focus into it; when it closes, return focus to a sensible element.
- Verify that focus is not trapped permanently and does not disappear after navigation, validation, or an asynchronous update.
Pay particular attention to content loaded after an API request. If a search result, validation message, or error appears without a focus or announcement strategy, keyboard users may not know that the page changed.
2. Structure, names, and semantics
- Use one meaningful page heading and a logical hierarchy of headings beneath it.
- Check that landmarks such as navigation, main content, search, and complementary regions are identifiable and not unnecessarily duplicated.
- Confirm that links describe their destination and buttons describe their action.
- Ensure every form control has a programmatic label, and that related controls use fieldsets and legends where appropriate.
- Check accessible names and roles for custom widgets with browser inspection tools and a screen reader.
- Make status, success, and error messages available to assistive technology without forcing users to search the page.
3. Visual presentation
- Check text and essential graphical content against the required contrast expectations for the applicable WCAG conformance target.
- Test at increased text size and page zoom. Content should remain readable without clipping, overlapping, or hidden controls.
- Do not use color alone to communicate status, required fields, errors, or selection.
- Inspect hover, focus, active, disabled, and error states—not only the default design.
- Review animation and transitions. Users should have a way to reduce or stop nonessential motion, and critical information should not depend on animation.
4. Forms, errors, and API-driven states
Test empty, valid, invalid, incomplete, duplicate, unauthorized, expired-session, timeout, and server-error responses. Each state should identify what happened, explain how to recover, and preserve entered information where it is reasonable to do so. Validation should not rely solely on color or a message placed far from the affected field.
For backend-driven interfaces, include accessibility checks in API and contract testing. Confirm that error payloads provide stable, meaningful information that the front end can expose through labels, descriptions, and status announcements. The REST API testing guide and OpenAPI contract testing workflow can support this part of the release process.
WCAG reference table
| Area | What to verify | Typical evidence |
|---|---|---|
| Keyboard | All tasks work without a pointer; focus is visible and logical. | Manual keyboard script and screen recording or test notes. |
| Text alternatives | Informative images, icons, and status graphics have useful alternatives. | DOM review and screen-reader output. |
| Forms | Controls have labels, instructions, validation, and recoverable errors. | Completed valid and invalid test cases. |
| Contrast and resize | Text, controls, and meaningful graphics remain distinguishable at zoom. | Contrast tool results plus visual review. |
| Structure | Headings, landmarks, names, and relationships are meaningful. | Accessibility tree and screen-reader navigation. |
| Motion and timing | Time limits, animation, and changing content do not block completion. | Reduced-motion and slow-response tests. |
Manual test script
- Open the page with a fresh session and identify the page title and main heading.
- Complete the primary task using only the keyboard.
- Repeat the task with zoom and a narrow viewport.
- Submit empty and deliberately incorrect forms; record focus placement and error announcements.
- Trigger loading, empty, success, timeout, permission, and server-error states.
- Repeat the journey with a screen reader and note headings, landmarks, labels, status messages, and dialog behavior.
- Run an automated scan, then manually verify every reported issue and inspect likely false negatives.
Browser and assistive-technology matrix
| Environment | Useful coverage |
|---|---|
| Chromium-based browser + NVDA | Windows keyboard navigation, forms, landmarks, and dynamic announcements. |
| Firefox + NVDA | Cross-browser behavior and differences in accessibility-tree exposure. |
| Safari + VoiceOver | macOS and iOS-oriented interaction, gestures, focus, and announcements. |
| Keyboard-only browser testing | Focus order, traps, skip links, menus, dialogs, and custom widgets. |
| Mobile browser + platform screen reader | Responsive layouts, touch targets, orientation, and mobile form workflows. |
Issue-severity template
Record each finding consistently: severity, page or component, user journey, steps to reproduce, expected behavior, observed behavior, affected input method or assistive technology, WCAG area, screenshots or DOM evidence, suggested fix, owner, and retest status. Treat a complete task blocker, keyboard trap, or inaccessible authentication path as urgent. Prioritize issues that prevent core tasks, then address repeated component defects, confusing feedback, and lower-impact presentation problems.
Cadence and checkpoints
Run a lightweight accessibility check during every component or page change, a focused regression review before release, and a broader audit on a monthly or quarterly cadence appropriate to the product’s change rate. Test immediately after redesigns, navigation changes, authentication updates, new form flows, major browser updates, or changes to API response handling.
Keep a small regression suite for critical journeys. It should include keyboard completion, focus after route changes, form errors, modal behavior, loading announcements, and at least one failed backend response. Automated checks can run in continuous integration, while manual checks should be scheduled for components whose behavior depends on context.
How to interpret changes
Compare findings by component, journey, environment, and severity rather than counting issues alone. A reduction in scan warnings may not represent improvement if a new custom widget or API error path was never tested manually. Conversely, a rise in findings after adding a new test environment may reflect better coverage rather than a regression.
Look for recurring causes: missing shared labels, inconsistent focus handling, duplicated error rendering, inaccessible loading states, or a design token that produces weak contrast across many screens. Fixing the component or backend contract at its source is usually more durable than patching individual pages. After remediation, retest the original steps and nearby states, including success, empty, slow, and failure responses.
When to revisit
Revisit this checklist whenever a new page, component, form, route, authentication flow, or API response is introduced. Schedule a full review at least quarterly when the product changes regularly, and sooner after a redesign, framework migration, major browser or assistive-technology update, or accessibility-related support issue. Review the checklist itself twice a year to account for changes in WCAG guidance, browser behavior, accessibility APIs, and audit-tool capabilities.
To make the next review practical, keep a dated test log with the build version, browsers and assistive technologies used, journeys covered, automated-tool configuration, open issues, and retest results. Start each cycle with the highest-value user journey, run the keyboard script before visual polish, and include at least one API failure state. This creates an evidence trail that helps developers, testers, designers, and API owners prevent the same accessibility defects from returning.