Website accessibility testing works best as a layered process rather than a single scan. This guide compares browser checkers, automated accessibility testing, screen readers, keyboard checks, contrast tools, and CI integrations, then turns them into a repeatable audit checklist you can use before launch and whenever a site changes.
Overview
Accessibility testing tools help identify barriers that can prevent people from navigating, understanding, or completing tasks on a website. No individual tool can evaluate every part of an accessible experience. Automated scanners are useful for finding repeatable code and structure problems, while manual testing is needed for interaction, focus behavior, wording, reading order, and realistic task completion.
A practical test strategy combines several tool types:
| Tool or method | Useful for finding | What it cannot reliably prove |
|---|---|---|
| Browser accessibility checker | Missing labels, landmarks, heading issues, and some element-level violations | Whether the complete user journey is understandable or usable |
| Automated scanner | Repeatable rules across pages, templates, and builds | All WCAG issues, correct content meaning, or successful task completion |
| Keyboard testing | Focus order, keyboard traps, visible focus, and operability without a pointer | How the page behaves with a screen reader or other assistive technology |
| Screen reader testing | Announcements, names, roles, reading order, dynamic updates, and form feedback | Whether every user of every screen reader will have the same experience |
| Color-contrast tool | Text, icon, border, and control contrast measurements | Usability in context, meaning conveyed by color, or non-color visual clarity |
| CI integration | Regression detection during pull requests or deployments | A complete accessibility audit or human review |
Use automated results as evidence and prioritization, not as a declaration that a site is accessible. Before selecting a tool, check whether it can test the rendering environment you use, whether it supports authenticated or dynamic pages, whether it produces actionable element references, and whether its rules can be configured for your project.
Checklist by scenario
For a quick browser-based review
- Open the page in the browser and run an accessibility checker against the rendered state.
- Review violations and warnings separately. Confirm each result in the page rather than copying every message into a report.
- Inspect the affected element in context. A missing label, for example, may be fixed in markup, through an associated label element, or through an appropriate accessible name.
- Check key states such as menus opened, dialogs displayed, validation errors shown, and content loaded after an interaction.
- Record the page, component, selector or element description, observed problem, and suggested direction for remediation.
A browser accessibility checker is a strong first pass because it is fast and works on the page as users see it. It is not a substitute for checking the complete flow or testing with assistive technology.
For a pre-launch automated scan
- Create a page inventory covering templates, navigation, forms, search, account areas, error pages, and important content types.
- Scan representative pages instead of assuming that one page represents every component state.
- Group duplicate findings by shared component or template. Ten instances of the same faulty button may be one engineering fix with ten affected locations.
- Separate confirmed issues from needs-review results and false positives.
- Run the scan again after fixes and retain the before-and-after results.
Automated accessibility testing is particularly valuable when pages are generated from common templates. It can catch regressions early, but it may not recognize whether a heading accurately describes its section or whether error instructions are clear to a person completing a task.
For keyboard-only testing
Put the mouse aside and use the keyboard to complete the site’s main tasks. Use this worksheet for each flow:
- Starting point: Can you reach the page and understand where focus begins?
- Navigation: Can you reach every link, button, field, menu item, tab, and dialog control?
- Focus visibility: Is the current focus indicator consistently visible against the background?
- Focus order: Does focus move in an order that matches the content and task?
- Interaction: Can you open, close, submit, expand, select, and undo controls without a pointer?
- Escape route: Can you leave menus, pop-ups, carousels, and dialogs without becoming trapped?
- Completion: Are success messages, validation errors, and changed states reachable and understandable?
Test both a narrow and wide viewport when layout changes affect the order or visibility of controls. Keyboard testing often exposes problems that an automated scan can only describe indirectly.
For screen reader and content-structure testing
Choose a screen reader and browser combination used by your team, document the setup, and test the highest-value journeys. Listen for the page title, landmark structure, headings, link purpose, form labels, instructions, required states, error messages, table relationships, and announcements after dynamic updates.
Do not test only by reading from top to bottom. Navigate by headings, landmarks, links, and form fields where the screen reader supports those modes. If the page becomes confusing when navigated by structure, inspect the underlying HTML and accessible names. A valid visual design does not guarantee a useful non-visual reading order.
For color, contrast, and visual clarity
Use a contrast tool to check text against its actual background, including text over images, gradients, hover states, disabled states, and focus indicators. Check meaningful icons, borders, charts, and form boundaries where contrast affects recognition. Then ask whether color is carrying information by itself. Error, success, selection, and status should have another cue such as text, an icon with an accessible name, a pattern, or a change in structure.
For continuous integration
Add automated checks to the build or pull-request workflow when the test environment can reliably render the relevant pages. Start with a manageable set of representative routes and fail the build only for findings your team has agreed are actionable. Publish the results so developers can see the affected page and element. A CI check is most useful when it prevents regressions without encouraging people to ignore noisy or unexplained output. For related workflow troubleshooting, see the GitHub Actions YAML troubleshooting guide.
What to double-check
Prioritize by user impact
When triaging findings, consider whether the issue blocks a primary task, affects many pages, exposes sensitive information, or leaves users without a recovery path. A keyboard trap in a checkout dialog deserves immediate attention. A minor issue on a low-use page may be scheduled differently, but it should still have an owner and a follow-up date.
Verify the fix in the rendered state
Check the actual page after implementation, not just the source code or ticket description. Confirm that a label is associated with the correct field, that a dialog moves focus appropriately, that an error is announced when it appears, and that a repaired contrast value remains valid in every relevant state.
Use a consistent issue report
Every report should include:
- Summary: a short description of the barrier.
- Location: URL, template, component, and affected element.
- Reproduction steps: the exact actions and test setup.
- Observed result: what happens now.
- Expected result: what a user should be able to do or perceive.
- Impact and priority: which task is affected and how broadly.
- Evidence: a tool result, screenshot where useful, code reference, or screen-reader observation.
- Verification: the test that will confirm the fix.
Keep standards references tied to the requirement being tested, and confirm that your team is using the applicable WCAG guidance for the project rather than relying on an old checklist copied from another site.
Common mistakes
- Treating a clean scan as compliance: automated tools detect only the rules they can evaluate programmatically.
- Testing only the home page: forms, dialogs, account areas, checkout steps, and error states often contain different accessibility risks.
- Ignoring warnings: a warning may require human judgment rather than dismissal.
- Checking only static content: menus, notifications, autocomplete fields, tabs, and single-page application updates need interaction testing.
- Using color contrast as the entire visual review: contrast does not address zoom, reflow, focus visibility, text spacing, or information conveyed only by color.
- Reporting symptoms without context: “button failed” is less useful than describing the route, action, expected announcement, and affected control.
- Running tools without a baseline: without a saved result or issue register, teams may not know whether a release improved or regressed accessibility.
When to revisit
Revisit your accessibility testing workflow before a launch, after a redesign, when a shared component changes, and whenever navigation, forms, authentication, content templates, or JavaScript behavior changes. Repeat checks after browser, framework, testing-library, or CI workflow changes as well; tool output and supported rules can evolve.
For recurring audits, keep a small regression suite containing the most important user journeys. Run automated scans in the normal development workflow, then schedule manual keyboard and screen-reader reviews at meaningful release points. Refresh browser-extension compatibility, scanner configuration, supported rules, and the project’s WCAG references when standards or major tool versions change.
Practical next step: choose three representative pages today: a content page, a form, and an interactive page such as a menu or dialog. Run an automated scan, complete the keyboard worksheet, verify contrast and focus states, and test the primary flow with a screen reader. Turn confirmed findings into issues using the report template above, assign owners, and rerun the same checks after fixes. That combination gives you a repeatable baseline instead of a one-time accessibility score.