Creating Accessible Web Applications with Angular

Anton Ioffe - November 27th 2023 - 10 minutes read

In an era where digital inclusivity forms the cornerstone of user-centric design, Angular emerges as a potent ally for developers striving to craft web applications that resonate with every user. This article invites seasoned developers to explore strategic paths to embed accessibility deep within the Angular development lifecycle. Prepare to harness the framework's innate automation prowess, unlock semantic intricacies with Angular directives, dynamically orchestrate ARIA attributes, and ensure your single-page applications communicate seamlessly with assistive technologies. The journey extends beyond the mundane, tackling advanced accessibility scenarios utilizing the robust Angular CDK and Material libraries. Each section is interspersed with pragmatic code insights, propelling your Angular projects into the vanguard of accessible web development.

Leveraging Angular's Automation for A11y

To enhance accessibility within Angular applications, a concoction of automated tools and strict code checks sows the seeds for an a11y-conscious development environment. The cornerstone of this process is the Angular ESLint suite with its included a11y linting rules, specifically tailored to catch common accessibility pitfalls early in the development process. By configuring the .eslintrc.json file, developers can enforce rules such as ensuring alternative text for images and appropriate content for accessibility elements. For example:

// .eslintrc.json
  "rules": {
    "@angular-eslint/template/accessibility-alt-text": "error",
    "@angular-eslint/template/accessibility-elements-content": "error",
    //...additional rules...

These linting rules are invaluable when integrated into the Continuous Integration (CI) pipeline. During automated builds, the CI tools can perform a comprehensive linting pass. Scanning the entire codebase, they flag any a11y issues, halting the pipeline if violations are detected. This safeguard ensures that no code that falls short on a11y standards makes it to production unnoticed. The result is not only a perpetuation of best practices but also a substantial improvement in a11y compliance.

For runtime a11y audits, Angular applications can leverage Lighthouse—an open-source, automated tool for improving the quality of web pages. To integrate Lighthouse checks within the CI workflow more effectively, a CI script should be set up to handle the building and serving of the Angular application before running the Lighthouse audit. Here is an enhanced CI script example:

// CI script for an Angular project
npm install
ng build --prod
npm install -g http-server
http-server ./dist/project-name -p 8080 &
npx wait-on http://localhost:8080
npx lighthouse http://localhost:8080 --only-categories=accessibility --output=json --output-path=./lighthouse-report.json
kill $(jobs -p) || true

This script outlines a workflow where the application is first built for production, then served using a simple http-server. The wait-on utility is used to pause the script execution until the server is ready to respond to requests. After the server is up, Lighthouse performs an accessibility audit. Finally, any background jobs, such as the http-server, are terminated.

The audit results can then be analyzed to ensure that the app adheres to the specified a11y criteria before deployment. Violations detected by the automated tools can be viewed as an opportunity to iteratively improve the accessibility of the application.

Not only does automation fast-track the detection of issues, but it also complements the indispensable practice of manual testing. It's important to remember that no amount of automation can supplant the nuanced scrutiny of human examination. Consider automated tools as sentinels that keep a vigilant watch for a11y concerns, freeing developers to invest more effort into the nuances of user experience that automation can miss.

Lastly, it's worthwhile to reflect on how the tight mesh of automated and manual accessibility testing within your Angular projects influences the overall a11y health of your applications. Are there opportunities to fine-tune your linting rules or your CI/CD pipeline to better serve users with disabilities? How much has automation improved the a11y compliance rate of your projects, and where can human expertise further this success? The answers to these questions continually shape an evolving approach to accessibility in Angular applications.

Semantic Markup and Angular Directives

Semantic markup plays a crucial role in creating accessible web applications. In Angular development, leveraging the power of native HTML elements alongside Angular directives greatly improves the accessibility of your applications. The use of non-semantic tags, such as div or span, for interactive controls can be problematic for users who rely on assistive technologies. Native HTML elements such as button, input, select, and a come with built-in accessibility features that are often lost when these are replaced with non-semantic markup.

For instance, consider a scenario where non-semantic markup is being used for interactive elements:

<div class="button" role="button" tabindex="0" (click)="executeAction()">Click me</div>

Here, a div element is styled and scripted to behave like a button. However, this creates additional effort to ensure keyboard accessibility and proper roles for screen readers. Instead, employing a semantic approach by using an actual button tag can offer a more robust solution:

<button (click)="executeAction()">Click me</button>

The latter example showcases a semantic element with Angular's (click) directive. This pattern maintains accessibility while cleanly integrating JavaScript functionality, eliminating the need for additional attributes to emulate native button behavior.

Furthermore, Angular directives can be utilized to enhance native elements rather than replace them. For example, using ngFor to create a list of elements should maintain the use of appropriate list tags:

  <li *ngFor="let item of items">{{ }}</li>

By using ul and li tags in combination with ngFor, you can preserve the list semantics, which aids screen readers in understanding the content structure.

Another common mistake is overlooking the document flow and structure. Screen readers depend on a logical document structure to navigate content effectively. Angular applications should use appropriate heading levels (h1 through h6) and structural elements like nav, article, and section. Misusing or skipping these elements can disorient users as they can't perceive the intended hierarchy or navigation aids.

Consider the usage of aria-label and other ARIA attributes for adding additional context where native HTML might fall short. A slider, for example, while being a native input element, might require additional ARIA attributes for full screen reader support:

<input type="range" aria-label="Volume control" min="0" max="100">

This code snippet not only uses a semantic input element of type range but also provides a clear label that screen readers can announce, making it accessible to users with visual impairments.

In conclusion, always prioritize semantic HTML and employ Angular directives to enhance, rather than replace, the inherent accessibility features of these elements. Such practices result in more accessible web applications, respecting the needs of all users and adhering to best practices in web development.

Dynamic A11y Attributes with Angular's Data Binding

Angular’s data-binding capabilities offer a systematic and efficient way to manage ARIA attributes dynamically. By utilizing Angular’s property bindings, developers can react to state changes in their application and convey these updates to assistive technologies. For instance, binding aria-pressed to a button’s state can inform a user that the button is active. Consider the following code snippet:

    Toggle State

Here, isToggleButtonActive is a component property which reflects the current state of the button. When the button is clicked, the toggleButtonState() method updates isToggleButtonActive, and consequently, the aria-pressed attribute changes to communicate the new state to screen readers.

Next, consider the scenario where a slider's value and label change based on user interaction. Angular’s event and property bindings can be used to adjust aria-valuenow and aria-label correspondingly. By introducing an input event, we can ensure that every change in the slider is captured and processed:

<input type="range"

The updateSlider method handles the event and updates sliderValue and sliderLabel, thereby keeping the screen reader informed of changes in real-time.

Dealing with complex widgets that possess roles such as listbox or menu requires managing the focus and selection state. The ListKeyManager class from the Angular CDK’s a11y module can be utilized along with data binding to manage keyboard navigation and active items effectively. Here’s an illustration of using ListKeyManager with Angular’s binding syntax:

<ul [attr.role]="'listbox'">
    <li *ngFor="let item of items" 
        [attr.aria-selected]="item === activeItem"
        {{ item }}

In this example, activeItem represents the currently active item in the list. The mousedown event is used to set the active item, affecting the aria-selected state of the list items.

Finally, ensuring that custom components or directives reflect the appropriate accessibility state requires thorough attention to detail in data binding. Developers should be mindful of the properties that affect the accessibility tree and bind them accordingly. A common mistake is neglecting custom state indicators, which include aria-expanded for collapsibles or aria-checked for custom checkbox implementations. The correction involves binding these properties to their respective state variables:

    Custom Checkbox

Here, isChecked updates the aria-checked attribute as the user interacts with the custom checkbox, ensuring that its state is communicated effectively to assistive technologies. Such practices exemplify comprehensive a11y support through Angular’s dynamic attribute binding, streamlining the creation of accessible web applications.

Accessible Single Page Application (SPA) Routing in Angular

Ensuring that navigational changes within Angular's single-page application (SPA) architecture are perceivable by all users is essential for creating an accessible web experience. For individuals using assistive technologies, this requires diligent management of focus and seamless announcement of page transitions.

Focus can be managed programmatically to enhance accessibility. When a user routes to a new component, Angular should direct focus to an element that reflects the new content, typically the main heading or section. This practice assists screen readers in recognizing content changes. Below is a refined example, demonstrating how focus is shifted in a component:

import { Component, ElementRef, OnInit, ViewChild, OnDestroy } from '@angular/core';
import { Router, NavigationEnd } from '@angular/router';
import { filter, Subscription } from 'rxjs';

    selector: 'app-main-content',
    template: `
        <h1 tabindex="-1" #contentHeader>{{title}}</h1>
export class MainContentComponent implements OnInit, OnDestroy {
    title = 'Welcome Page';
    @ViewChild('contentHeader') contentHeader: ElementRef;
    private routerSubscription: Subscription;

    constructor(private router: Router) {}

    ngOnInit() {
        this.routerSubscription =
            .pipe(filter(event => event instanceof NavigationEnd))
            .subscribe(() => {

    ngOnDestroy() {
        if (this.routerSubscription) {

In the snippet above, focus shifts to the contentHeader upon route completion, which is triggered by the NavigationEnd event from Angular's router. This is particularly important for significant navigational shifts, to avoid disorienting users during minor context changes.

Announcements of navigational changes for screen readers are best handled by utilizing Angular's Title service and the prudent application of aria-live attributes. Angular's Title service is instrumental in updating the browser's title, a feature inherently announced by screen readers. To address this, update your routing module to include a title property for each path:

const appRoutes: Routes = [
    { path: 'welcome', component: WelcomeComponent, title: 'Welcome - Accessible Angular SPA' },
    // ... additional routes

    imports: [RouterModule.forRoot(appRoutes)],
    exports: [RouterModule]
export class AppRoutingModule { }

Utilize the Title service alongside Angular's router mechanism to dynamically modify the page title on navigation:

import { Title } from '@angular/platform-browser';
import { Component, OnInit } from '@angular/core';
import { Router, NavigationEnd, ActivatedRoute } from '@angular/router';
import { filter, map, mergeMap } from 'rxjs/operators';

    selector: 'app-root',
    template: '<router-outlet></router-outlet>'
export class AppComponent implements OnInit {

        private titleService: Title,
        private router: Router,
        private activatedRoute: ActivatedRoute
    ) {}

    ngOnInit() {
                filter(event => event instanceof NavigationEnd),
                map(() => this.activatedRoute),
                map(route => {
                    while (route.firstChild) route = route.firstChild;
                    return route;
                filter(route => route.outlet === 'primary'),
                mergeMap(route =>
            .subscribe(event => this.titleService.setTitle(event['title']));

Care must be taken when implementing aria-live regions. They should serve only the purpose of conveying relevant content changes, without overloading the user with unnecessary announcements.

It is vital to avoid common mistakes such as failing to dismantle page-specific event listeners when navigating away from a view. Use the ngOnDestroy method to ensure cleanups are executed properly, preventing potential memory leaks or erratic behaviors.

Consider how each new development might influence a user's navigation and maintain an accessible pathway. What strategies would you deploy to ensure that your focus management and route announcements are both comprehensive and unintrusive, enhancing user experience while respecting their cognitive space?

Addressing Advanced A11y Scenarios with Angular CDK and Material

When building complex web applications, developers often encounter advanced accessibility (a11y) challenges, particularly with dynamic content such as modals, tooltips, and custom form controls. Angular's Component Development Kit (CDK) and Angular Material provide powerful tools to address these issues effectively. For instance, managing focus within a modal dialog is crucial for users relying on keyboards and screen readers. Angular CDK's FocusTrap ensures that tabbing through the elements does not escape the confines of the dialog.

import { FocusTrapFactory } from '@angular/cdk/a11y';

export class MyDialogComponent implements AfterViewInit {
  private focusTrap: FocusTrap;

  constructor(private focusTrapFactory: FocusTrapFactory, private elementRef: ElementRef) {}

  ngAfterViewInit() {
    // Create a focus trap around the dialog
    this.focusTrap = this.focusTrapFactory.create(this.elementRef.nativeElement);

  ngOnDestroy() {
    this.focusTrap.destroy(); // Clean up the focus trap

Communicating dynamic changes such as error notifications or state updates to screen readers without disrupting the user flow can be challenging. The LiveAnnouncer service from Angular CDK can dynamically announce messages, handling ARIA live regions under the hood.

import { LiveAnnouncer } from '@angular/cdk/a11y';

export class MyCustomComponent {
  constructor(private liveAnnouncer: LiveAnnouncer) {}

  announceMessage(message: string) {
    this.liveAnnouncer.announce(message, 'assertive');

Designing for users with visual impairments sometimes requires high-contrast themes. Angular Material, in conjunction with Angular CDK, offers an @mixin that simplifies the creation of such themes. The cdk-high-contrast mixin can be applied to components that benefit from high-contrast styling.

@mixin custom-component-high-contrast($selector) {
  @include cdk-high-contrast {
    #{$selector} {
      outline: 1px solid white;
      background: black;

Advanced usability ensures all users can navigate and interact with web applications effortlessly, but implementing such features raises complexity. Employing Angular CDK and Material a11y tools offers an elegant balance, reducing the intricacies of managing a11y concerns in dynamic and interactive elements. These out-of-the-box solutions align with best practices, decreasing the potential for common coding mistakes, such as neglecting focus management or ARIA live region updates, while enhancing the user experience for all.

This hands-on approach not only improves the developer's workflow but also fosters an inclusive environment where accessibility is integral to the development process. How often do you audit your application for advanced accessibility considerations, and could your existing components benefit from incorporating such Angular CDK features?


This article explores how to create accessible web applications with Angular. It discusses leveraging Angular's automation tools and linting rules to catch accessibility issues early in the development process. The article also emphasizes the importance of semantic markup and the use of Angular directives to enhance native accessibility features. Additionally, it covers dynamic management of ARIA attributes using Angular's data binding capabilities and addresses the challenges of creating accessible single-page application (SPA) routing. Furthermore, the article highlights the use of Angular CDK and Material libraries to tackle advanced accessibility scenarios. The reader is challenged to think about how each development decision can influence navigation and to consider strategies for managing focus and route announcements in an accessible and user-friendly manner.

Don't Get Left Behind:
The Top 5 Career-Ending Mistakes Software Developers Make
FREE Cheat Sheet for Software Developers