A reliable accessibility audit combines automated checks with hands-on testing. This guide gives you a repeatable checklist for reviewing semantic HTML, keyboard navigation, focus management, accessible names, forms, color, dynamic content, reduced motion, and screen-reader behavior before a release.
Overview
Accessibility testing is most effective when it is treated as a release process rather than a one-time scan. Automated tools can identify useful patterns, such as missing alternative text, low color contrast, duplicate identifiers, and form controls without labels. They cannot fully determine whether a keyboard user can complete a task, whether focus moves logically, or whether a screen reader announces an update at the right moment.
Use this accessibility testing checklist at three levels:
- Component level: test buttons, menus, dialogs, inputs, tables, tabs, and other reusable UI patterns while they are being built.
- Page level: review headings, landmarks, navigation, forms, links, and content relationships on a complete route.
- Task level: complete important user journeys using only a keyboard and then with a screen reader smoke test.
Record each issue with its location, reproduction steps, affected task, expected behavior, actual behavior, and suggested fix. A repeatable record makes regressions easier to spot and helps teams distinguish a new defect from an unresolved one.
What to track
1. Semantic structure and page landmarks
Start with the document structure before inspecting visual styling. Confirm that the page has one clear <main> region, meaningful headings, and landmarks that reflect the interface. Use native HTML elements when they match the behavior you need.
<header>
<nav aria-label="Primary navigation">...</nav>
</header>
<main>
<h1>Account settings</h1>
<section aria-labelledby="notifications-heading">
<h2 id="notifications-heading">Notifications</h2>
...
</section>
</main>
Check that headings describe the content that follows rather than serving only as visual labels. Do not add heading levels merely to obtain a particular font size; use CSS for presentation and preserve a logical content hierarchy.
2. Keyboard navigation and focus order
Disconnect the mouse and complete the primary tasks with the keyboard. Use Tab, Shift + Tab, Enter, Space, and arrow keys where the component requires them. Track whether:
- Every interactive control can receive focus.
- The focus order follows the intended reading and task order.
- Focus indicators remain visible against the background.
- There are no keyboard traps, especially inside dialogs, menus, and custom widgets.
- Opening an overlay moves focus into it and closing it returns focus to a sensible trigger.
- Keyboard users can reach and operate controls that appear on hover.
Avoid removing outlines without replacing them with an equally clear focus treatment. A simple baseline pattern is:
:focus-visible {
outline: 3px solid #155eef;
outline-offset: 3px;
}
Test the focus style on every major surface, including dark themes, error states, cards, tables, and elements placed over images.
3. Accessible names for controls
Buttons, links, inputs, and other controls need names that convey their purpose. An icon-only button should not rely on its shape or position to communicate meaning.
<button type="button" aria-label="Close dialog">
<svg aria-hidden="true" viewBox="0 0 24 24">...</svg>
</button>
Prefer visible text when possible. If a control has visible text, do not add a conflicting label that causes assistive technology to announce something different. For links, replace vague text such as “Read more” with a destination that remains meaningful when read out of context.
4. Forms, errors, and instructions
Review every form as both a data-entry task and an error-recovery task. Each input should have a programmatic label, instructions when needed, and an error message that identifies what must change.
<label for="email">Email address</label>
<input
id="email"
name="email"
type="email"
autocomplete="email"
aria-describedby="email-help email-error"
aria-invalid="true"
>
<p id="email-help">Use the address associated with your account.</p>
<p id="email-error" role="alert">
Enter a valid email address.
</p>
Check that errors are not communicated by color alone, that the invalid field is easy to locate, and that focus moves only when the change helps the user recover. For a long form, summarize errors near the top and link each summary item to its corresponding field.
5. Images, color, and non-text content
Classify every image as informative, decorative, or functional. Informative images need concise alternative text. Decorative images should be hidden from assistive technology with an empty alt value. Functional images need alternative text that describes the action, not the pixels.
Inspect text, icons, borders, charts, and status indicators for sufficient contrast. Also verify that meaning is not conveyed through color alone. A required field, validation state, or chart series should have an additional cue such as text, an icon with an accessible name, a pattern, or a direct relationship to a label.
6. Dynamic content and application state
Single-page applications often update the visual interface without changing the document focus. Test loading messages, validation errors, toast notifications, filtering results, modal dialogs, expandable sections, and route changes.
<div id="status" role="status" aria-live="polite"></div>
<script>
const status = document.querySelector('#status');
status.textContent = 'Results updated';
</script>
Use live regions selectively. Announcing every small change can make a page difficult to use. For important state changes, confirm that the message is exposed once, is understandable without visual context, and does not interrupt an unrelated task.
7. Reduced motion and responsive behavior
Test the interface at narrow and wide viewport sizes, with increased text size where practical, and with motion preferences enabled. Decorative animation should not be the only way to understand a state, and essential content should remain available when transitions are disabled.
@media (prefers-reduced-motion: reduce) {
*,
*::before,
*::after {
animation-duration: 0.01ms !important;
animation-iteration-count: 1 !important;
transition-duration: 0.01ms !important;
scroll-behavior: auto !important;
}
}
Do not treat this rule as a complete motion review. Confirm that removing movement does not hide focus changes, make a control appear frozen, or prevent a user from understanding what happened.
8. Screen-reader smoke tests
A full assistive-technology test matrix depends on your audience, operating systems, browsers, and application complexity. For a practical smoke test, choose one supported desktop or mobile combination and complete the most important task without relying on the screen. Listen for the page title, main heading, landmarks, form labels, button names, errors, dialog boundaries, and confirmation messages.
Do not infer accessibility from a single successful announcement. Repeat the task after a validation failure, an empty result, a loading state, and a permission or authentication error. These states often expose missing labels or poorly managed focus.
Cadence and checkpoints
Use a layered schedule so that testing happens early enough to be useful:
| Checkpoint | What to review | Suggested record |
|---|---|---|
| During component development | Semantics, keyboard behavior, focus visibility, accessible names, and states | Component test case and known limitations |
| Before merging a feature | Automated scan plus keyboard completion of the changed flow | Issue links, screenshots, and reproduction steps |
| Before a release candidate | Critical journeys, forms, responsive layouts, dynamic updates, and screen-reader smoke tests | Pass, fail, blocked, or not applicable for each journey |
| After a redesign or framework change | Shared components, routing, focus management, and generated markup | Regression comparison against the previous release |
| Monthly or quarterly | Representative pages, browser and assistive-technology combinations, and unresolved defects | Trend log and next remediation priorities |
Run automated checks in development and continuous integration where possible, but keep manual checks in the release checklist. A tool result is evidence to investigate, not a substitute for completing a user task.
How to interpret changes
Prioritize issues by user impact and task criticality rather than by the number of tool findings. A missing label on a primary account form may deserve attention before several low-impact issues on an infrequently used page.
| Priority | Typical signal | First response |
|---|---|---|
| Blocker | A user cannot complete a critical task with a keyboard or assistive technology | Stop release of the affected flow and create a focused reproduction |
| High | Important information, errors, or controls are unavailable or confusing | Assign an owner and verify the fix with the affected interaction |
| Medium | The task works but includes unclear structure, weak focus treatment, or avoidable friction | Schedule remediation with the component or page owner |
| Low | Minor consistency or enhancement issue with limited task impact | Track it for component-library or maintenance work |
When a score changes, investigate the cause instead of comparing numbers in isolation. A redesign may add new pages and increase findings even while the percentage of affected tasks falls. Conversely, a clean automated scan may hide a keyboard trap introduced by a custom menu. Compare the same routes, journeys, tools, and test conditions whenever you are measuring progress.
When fixing a repeated problem, repair the shared component or template rather than patching each page. For example, correcting the dialog focus cycle in one reusable dialog component is more durable than adding page-specific event handlers. After changing shared code, rerun every flow that uses it.
For related frontend debugging work, keep accessibility findings alongside other release evidence. A TypeScript error, a failed CORS request, or a changed API response can alter the rendered state and create an accessibility regression even when the accessibility code itself was not edited. The TypeScript type errors troubleshooting guide and CORS troubleshooting guide can help isolate those supporting failures.
When to revisit
Revisit this accessibility audit checklist for every release candidate that changes navigation, forms, authentication, content structure, shared components, or dynamic application states. Repeat the review after a major framework or browser change, a redesign, a new third-party widget, or a change to the supported assistive-technology environment.
For routine maintenance, schedule a representative audit monthly or quarterly. Rotate the pages and user journeys so that high-value areas receive regular coverage without requiring a full site review every time. Keep a dated record of the browser, operating system, screen reader, viewport, route, and result.
Before marking an issue resolved, use this practical closeout sequence:
- Describe the user task that failed and the expected accessible behavior.
- Apply the smallest semantic or component-level fix that addresses the cause.
- Run the automated check again, then repeat the keyboard steps manually.
- Repeat the screen-reader smoke test for the changed state, including errors and empty results.
- Check a second route or component instance if the fix affects shared code.
- Record the test conditions and link the result to the release or component change.
Accessibility testing becomes sustainable when the checklist is short enough to run often and detailed enough to produce an actionable result. Keep the core checks in your pull-request and release workflows, expand them when recurring defects appear, and review the checklist at least twice a year so that its browser, assistive-technology, framework, and standards references remain appropriate.