Inspiration
As a product designer and front-end developer, I believe technology should empower everyone, regardless of their abilities.
However, digital accessibility is still frequently overlooked during product development. Many websites contain barriers that make everyday tasks difficult for people who rely on assistive technologies.
I created AccessPilot AI to help bridge this gap by making accessibility testing easier to understand, more actionable, and accessible to developers, designers, and beginners.
My goal was simple: make building inclusive digital experiences easier for everyone.
What It Does
AccessPilot AI is a privacy-first, browser-based accessibility assistant that analyzes HTML source code, identifies potential accessibility issues, and provides actionable recommendations.
Its key features include:
Automated Accessibility Analysis: Examines HTML against 10 WCAG-informed accessibility rule categories.
Intelligent Issue Prioritization: Uses a lightweight machine learning model to suggest which issues deserve attention first.
Actionable Recommendations: Explains accessibility concerns and provides practical examples of possible fixes.
Interactive Dashboard: Displays findings in an intuitive, responsive interface.
Ready-to-Test Examples: Includes checkout, news article, and accessible-page scenarios.
Exportable Reports: Generates downloadable JSON and HTML accessibility reports.
Privacy-First Architecture: Processes everything locally in the browser without uploading source code or requiring API keys.
The project helps teams move from simply identifying accessibility concerns toward understanding how to address them.
How I Built It
I developed AccessPilot AI using a lightweight, dependency-free web architecture.
Technologies used:
HTML5 for semantic page structure.
CSS3 for responsive layouts and accessible visual design.
JavaScript for application logic and interactions.
DOMParser for analyzing HTML directly in the browser.
A custom k-nearest neighbors (KNN) classifier for issue prioritization.
WCAG-informed rules for accessibility analysis.
GitHub for source control.
Vercel for deployment.
The application follows a straightforward process:
Users paste HTML code or select an example page.
The application parses the HTML locally.
Deterministic accessibility rules identify potential problems.
A three-nearest-neighbors classifier suggests issue priorities.
The dashboard presents findings, explanations, and possible improvements.
Users review the results and export a report.
The machine learning component uses 12 handcrafted synthetic training examples and considers estimated impact, prevalence, and persistence.
Importantly, the classifier prioritizes findings rather than determining whether something violates an accessibility standard. This keeps accessibility evidence separate from illustrative machine learning predictions.
AI tools also assisted with implementation, testing, documentation, and demonstration materials during development.
Challenges I Faced
- Making Accessibility Understandable
Accessibility standards contain detailed technical requirements that can be difficult for beginners to interpret.
The challenge was translating technical findings into understandable explanations and practical recommendations.
- Balancing AI and Reliability
Machine learning predictions can introduce uncertainty.
I addressed this by separating deterministic accessibility detection from machine learning prioritization, ensuring that the ranking system does not invent accessibility violations.
- Protecting User Privacy
Developers may need to analyze confidential application source code.
I designed the application to run entirely in the browser, eliminating the need to transmit HTML content to external servers.
- Designing an Accessible Tool
An accessibility product should demonstrate the principles it promotes.
I focused on semantic HTML, responsive layouts, readable typography, strong visual contrast, and keyboard-operable controls.
- Understanding Automated Testing Limitations
Static HTML analysis cannot identify every accessibility problem.
Issues involving screen readers, color contrast, dynamic content, focus management, and real-world usability still require additional testing.
I documented these limitations explicitly to avoid presenting the tool as an accessibility certification service.
Accomplishments I'm Proud Of
I'm particularly proud of:
Building a functional accessibility analysis prototype without external dependencies.
Implementing 10 categories of WCAG-informed checks.
Integrating explainable machine learning prioritization.
Creating an intuitive interface that makes findings easier to understand.
Enabling fully local analysis without user accounts or external APIs.
Supporting downloadable accessibility reports.
Creating three demonstration scenarios to illustrate different accessibility outcomes.
Publishing the source code and preparing a public application deployment.
The application was also tested locally in Chromium using its demonstration scenarios.
What I Learned
Building AccessPilot AI reinforced several important lessons.
Accessibility is more than compliance. It is about understanding how people with different abilities experience digital products.
AI should support human judgment. Machine learning can help organize information, but transparent evidence and human validation remain essential.
Privacy can be a core product feature. Useful intelligent experiences do not always require cloud services or external AI APIs.
Simplicity creates value. A focused application with understandable recommendations can make complex technical topics more approachable.
Most importantly, I learned that designing for inclusion should begin at the earliest stages of development.
What's Next for AccessPilot AI
I plan to evolve AccessPilot AI through several improvements:
Expanded Accessibility Testing: Integrate axe-core and additional WCAG-informed checks.
Live Website Analysis: Add optional analysis of rendered web pages beyond pasted HTML.
Improved Machine Learning: Validate issue prioritization using annotated real-world examples.
Developer Workflow Integration: Explore integrations with development tools and continuous integration pipelines.
Accessibility Research: Gather feedback from accessibility specialists and people who use assistive technologies.
Enhanced Reporting: Provide richer remediation guidance and clearer progress tracking.
My long-term vision is to make accessibility a natural part of the digital product development lifecycle.
AccessPilot AI represents a step toward a future where digital accessibility is built into every experience from the beginning.
Project Links
Live Application: https://accesspilot-ai-samertalls-projects.vercel.app
GitHub Repository: https://github.com/samertall/accesspilot-ai
Demo Video: https://accesspilot-ai-samertalls-projects.vercel.app/accesspilot-demo.mp4
AccessPilot AI is an educational prototype. Its automated findings do not constitute complete WCAG compliance verification, and its illustrative machine learning model has not been validated as a production predictive system.
