How-to Guides Archives- Page 3 of 8/Category

Why No ARIA Is Better Than Bad ARIA
It’s tempting to think of ARIA (Accessible Rich Internet Applications) as the one-stop solution for all your accessibility needs. After all, ARIA exists to help developers create web content that works better for people who use assistive technology, like screen readers. But here’s the catch: if you misuse ARIA—or in places where it isn’t needed—you can end up making your site less accessible, not more.

This post will explain why semantic HTML should always be your go-to approach, when and why ARIA is beneficial, the most common ARIA mistakes, and best practices for getting it right. By the end, you’ll see how “less is more” often applies to ARIA and why sticking to native elements can save you—and your users—a lot of trouble.

What Is ARIA (and Why Does It Matter)?

ARIA stands for Web Accessibility Initiative – Accessible Rich Internet Applications. Created by the World Wide Web Consortium (W3C), ARIA provides a set of roles, states, and properties that help assistive technologies (like screen readers) understand the meaning and function of different elements on a webpage. It’s beneficial for complex or dynamic interfaces that native HTML elements don’t fully cover—such as custom sliders or tab interfaces.

However, the real power of ARIA depends on how it’s used. Applying ARIA roles in the wrong places or mislabeling states can lead to confusion and errors. Users relying on screen readers might hear incorrect information about what’s on the page or even miss out on essential controls. If you’re not cautious, you could do more harm than good.

Why Semantic HTML Should Be Your First Choice

Before jumping into ARIA, remember that semantic HTML is the foundation of accessible web design. Native elements, like <header>, <nav>, <button>, and <footer>, come with many built-in features that screen readers and other assistive tools already understand.

What is Semantic HTML?

It refers to HTML elements that clearly describe their meaning. For instance, a <nav> element signals that it contains navigation links. A <button> says, “I’m something clickable!” to both users and screen readers.

Why Does it Matter?

When you use semantic elements, you’re using markup that browsers and screen readers know how to interpret. This often means you don’t need ARIA at all—because everything is already handled for you.

Real-world Example

If you need a button, just use <button> instead of a <div> with role= "button". Screen readers automatically identify a <button> as a button, while a <div> is just a generic container. Adding a role= "button" to that <div> can work, but it’s extra code and is often less reliable than using a <button> in the first place.

By relying on these built-in elements, your code is simpler and more intuitive. You’re also less likely to cause confusion when you mix ARIA roles with native roles.

When (and Why) ARIA Is Actually Needed

So, if semantic HTML is so powerful, why do we have ARIA at all?

Filling the Gaps

HTML is great, but it’s not perfect. Some interactive elements—like complex sliders, tab panels, or sortable tables—aren’t natively supported (or are only partially supported) by standard HTML tags. ARIA helps fill in these gaps by providing additional metadata.

Roles, States, and Properties

ARIA is split into three main categories: roles (what is this thing?), states (what is its current condition?), and properties (how does it behave?). These allow screen readers to give users a clearer picture of what’s happening on the page.

Example: Tabs and sliders

If you’re building a tab interface from scratch, you might rely on a series of <div> elements. You’d need ARIA attributes like role= "tablist", role= "tab“, and role= "tabpanel", plus properties like aria-selected= "true" or aria-hidden= "true" to show which tab is active.

Ultimately, ARIA becomes crucial when the default HTML elements don’t cover the level of interactivity or complexity you need. That might be a custom widget or a specialized interface that doesn’t map neatly to existing HTML tags.

The Most Common ARIA Mistakes (and Why They’re a Problem)

Misusing Roles

Sometimes, developers add ARIA roles to elements out of habit, without stopping to see if the native element would have worked better. If you set role= "button" on a <div>, you must also manually manage keyboard interactions and focus states. If you don’t, assistive technology users may be unable to click or navigate to this “button” effectively.

Example
```

<div role="button" tabindex="0" onclick="doSomething()">
  Click me
</div>


<button onclick="doSomething()">Click me</button>
```
Using a <button> means you get keyboard focus, click events, and screen reader recognition by default—no extra ARIA or scripting needed.

Redundant or Conflicting Roles

Many elements come with built-in roles. A <nav> element is understood as “navigation,” and a <ul> is understood as a list. If you add role= "navigation" to a <nav>, you’re restating something already known. In some cases, overriding a native role with a custom role can even interfere with how assistive technologies interpret the element.

Example
```

<nav role="navigation">
  
</nav>


<nav>
  
</nav>
```
Here, adding role= "navigation" is unnecessary and could create confusion in some tools.

Incorrect State Management

ARIA states, like aria-expanded or aria-checked, must accurately reflect the element’s real condition. If your dropdown menu is closed but you have aria-expanded= “true”, a screen reader user will hear that the menu is open—even though it isn’t. This mismatch can be very disorienting.

Example
```

<button aria-expanded="true" onclick="toggleMenu()">Menu</button>


<button aria-expanded="false" onclick="toggleMenu()">Menu</button>
```
Make sure your script updates aria-expanded to reflect the actual state of the menu (true when open, false when closed).

ARIA Overload

Adding too many ARIA attributes can clutter the information that screen readers must process. For instance, overusing aria-live regions can cause screen readers to constantly read out changes that might not be important. This can frustrate users and cause them to miss critical content.

Example
```

<div aria-live="polite">Update 1</div>
<div aria-live="polite">Update 2</div>
<div aria-live="polite">Update 3</div>


<div aria-live="polite" id="importantUpdates"></div>
```
If you really need to announce multiple updates, try grouping them or letting users opt-in.

Misusing aria-hidden

aria-hidden= "true" tells screen readers to ignore an element. If you add this attribute to interactive content—like a button, form field, or link—you’re effectively locking out users who rely on assistive tech.

Important: Hiding something visually is not always the same as hiding it from screen readers. Don’t use aria-hidden if the content is still necessary for some users.

Example
```

<button aria-hidden="true" onclick="doSomething()">Buy Now</button>


<button class="visually-hidden" onclick="doSomething()">Buy Now</button>
```
(“Visually hidden” classes typically hide elements from sighted users but keep them available to assistive tech.)

Why “No ARIA” is Often the Best Choice

The golden rule is this: bad ARIA is worse than no ARIA at all. Why? Because at least with no ARIA, the user experience reverts to the default behaviors of native HTML, which assistive technologies are designed to understand. But if you add incorrect ARIA roles or states, you can mislead screen readers entirely.

In many cases, the standard HTML element does everything you need. By default, a <button> is keyboard-accessible, announces itself as a button, and can have an accessible label. Adding role= "button" to a <div> only means more overhead for you and possibly less clarity for users.

Best Practices for Using ARIA the Right Way

Use Native HTML First

Always check whether you can use a built-in HTML element. This approach is simpler to code, more reliable, and better for accessibility out of the gate.

Example

Instead of:

<div role="button" tabindex="0">Submit</div>

Use:

<button>Submit</button>

No extra attributes, no confusion—just a straightforward button.

Be Precise with Roles and States

If you must use ARIA, choose the exact role that matches the purpose of your element. Also, keep an eye on the current state—like aria-expanded, aria-checked, or aria-selected—and update it only when something changes.

Example
```
<button aria-expanded="false" aria-controls="menu" onclick="toggleMenu()">Menu</button>
<ul id= "menu" hidden>
  <li>Home</li>
  <li>Services</li>
  <li>Contact</li>
</ul>
```
In this example, setting aria-expanded= "false" on the button shows it’s not expanded. When the user clicks, you can switch that to true in your JavaScript.

Don’t Add ARIA Where It’s Not Needed

If an element already serves a clear function, adding a role that duplicates it is just noise for screen readers.

Example
```

<ul role="list">
  <li>Item 1</li>
  <li>Item 2</li>
</ul>


<ul>
  <li>Item 1</li>
  <li>Item 2</li>
</ul>
```
A <ul> is already recognized as a list by assistive technology.

Test with Real Assistive Tech

Tools like automated accessibility checkers are helpful, but they can’t catch everything. The best way to confirm your site’s accessibility is to test it with screen readers (like NVDA, JAWS, or VoiceOver) and try navigating entirely with a keyboard. If you can, get feedback from people who actually use these tools every day—they can point out mistakes or obstacles you might miss otherwise.

Conclusion

Using ARIA incorrectly can do more harm than good. In fact, it can make websites less accessible and confusing for users who rely on screen readers. The first step to building an accessible website is to stick with semantic HTML wherever possible. If you need ARIA—especially for complex custom widgets—be sure to use it carefully, accurately reflecting each element’s true roles and states. Then, test your work with real users and assistive technologies to make sure you’re making things better, not worse.

Following these guidelines helps create a smoother experience for every visitor, including those using assistive technology. Remember: if you can solve your problem with native HTML, do that first. If not, ARIA can be a fantastic tool—just be sure you’re using it correctly.

Need Help with Web Accessibility?

Making a website accessible can be tricky, especially when it comes to knowing how and when to use ARIA. 216digital specializes in web accessibility, from ARIA best practices to full WCAG compliance. If you’re ready to take the next step toward a more inclusive web experience, reach out to us today! Let’s work together to ensure your site remains welcoming—and functional—for every user.
Greg McNeil

February 4, 2025

How-to Guides

Accessibility, ARIA, How-to, WCAG, Web Accessibility, web developers, web development
Web Accessibility: Making Drop-Down Menus User-Friendly
Drop-down menus are a staple in website navigation, offering a compact way to organize and access multiple links. But while they streamline user experience, they can also create significant barriers if not designed with accessibility in mind. For users who rely on screen readers, keyboard navigation, or other assistive technologies, a poorly implemented menu can turn a simple browsing experience into a frustrating ordeal.

This article will guide website owners, developers, and content creators on how to create accessible drop-down menus that enhance usability for all users. We’ll cover foundational accessibility principles, best coding practices, and testing methods to ensure your menus are inclusive and user-friendly.

Foundational Accessibility Principles for Drop-Down Menus

To build accessible drop-down menus, start by understanding core web accessibility principles. Here are the three most critical aspects:

1. Use Semantic HTML

Semantic HTML ensures that content is meaningful and properly interpreted by assistive technologies. Instead of using <div> or <span> elements for interactive components, use appropriate HTML elements like:
- <nav> for navigation sections
- <ul> and <li> for menu structures
- <button> to toggle drop-down visibility
For example:
```
<nav>
  <button aria-haspopup="true" aria-expanded="false" id="menuButton">Menu</button>
  <ul id="menu" hidden>
    <li><a href="#">Home</a></li>
    <li><a href="#">About</a></li>
    <li><a href="#">Services</a></li>
    <li><a href="#">Contact</a></li>
  </ul>
</nav>
```
2. Ensure Keyboard Navigation

Users who navigate via keyboard should be able to open, close, and move through the menu using the Tab and arrow keys. Ensure the following behaviors:
- The menu should open with Enter or Space when focused on the toggle button.
- The Esc key should close the menu.
- Arrow keys should allow navigation within the menu items.
3. Use ARIA Roles and Attributes Wisely

ARIA (Accessible Rich Internet Applications) attributes help convey additional information to screen readers. However, improper use can create confusion. Apply ARIA roles correctly:
- aria-haspopup="true" indicates that a button controls a drop-down menu.
- aria-expanded="false" updates dynamically when the menu is opened or closed.
- role="menu" and role="menuitem" clarify the structure.
Example implementation:
```
<button aria-haspopup="true" aria-expanded="false" id="menuButton">Menu</button>
<ul id="menu" role="menu" hidden>
  <li role="menuitem"><a href="#">Home</a></li>
  <li role="menuitem"><a href="#">About</a></li>
  <li role="menuitem"><a href="#">Services</a></li>
</ul>
```
Structuring Accessible Drop-Down Menus

Now that we’ve covered the principles, let’s implement an accessible drop-down menu using HTML, CSS, and JavaScript.

1. Toggling Visibility

A menu should only be visible when needed. Use JavaScript to control visibility:
```
const menuButton = document.getElementById('menuButton');
const menu = document.getElementById('menu');
menuButton.addEventListener('click', () => {
  const expanded = menuButton.getAttribute('aria-expanded') === 'true';
  menuButton.setAttribute('aria-expanded', !expanded);
  menu.hidden = expanded;
});
```
2. Managing Focus for Keyboard Users

When a menu opens, focus should shift inside it. When it closes, focus should return to the toggle button:
```
toggle button:
menuButton.addEventListener('click', () => {
  menu.hidden = !menu.hidden;
  menu.hidden ? menuButton.focus() : menu.querySelector('a').focus();
});
```
3. Enabling Smooth Keyboard Interactions

To navigate the menu with arrow keys, use this approach:
```
menu.addEventListener('keydown', (event) => {
  const items = [...menu.querySelectorAll('a')];
  let index = items.indexOf(document.activeElement);
  
  if (event.key === 'ArrowDown') {
    event.preventDefault();
    index = (index + 1) % items.length;
    items[index].focus();
  } else if (event.key === 'ArrowUp') {
    event.preventDefault();
    index = (index - 1 + items.length) % items.length;
    items[index].focus();
  } else if (event.key === 'Escape') {
    menu.hidden = true;
    menuButton.focus();
  }
});
```
Testing Your Drop-Down Menus for Accessibility

1. Screen Reader Testing

Use a screen reader like NVDA (Windows), VoiceOver (Mac), or JAWS to ensure:
- Menus are announced properly.
- aria-expanded updates correctly.
- Navigation follows expected patterns.
2. Keyboard Testing

Try navigating your menu using only the keyboard. Ensure:
- Tab reaches the menu.
- Enter or Space opens the menu.
- Arrow keys move between items.
- Esc closes the menu.
3. Contrast and Readability

Ensure proper color contrast between text and background. Use tools like the WebAIM Contrast Checker to verify compliance with WCAG 2.1 standards.

Best Practices for Creating Intuitive Menus
- Keep It Simple: Avoid deep nesting that makes menus cumbersome.
- Ensure Mobile Friendliness: Use larger touch targets for better usability.
- Avoid Hover-Only Menus: They exclude keyboard users and some assistive technology users.
- Provide Visual Indicators: Show clear changes when menus expand or collapse.
Conclusion

By using semantic HTML, managing focus properly, implementing ARIA roles correctly, and rigorously testing your menus, you can ensure they work for all users, regardless of ability.

Accessible drop-down menus not only improve usability but also make your site more welcoming to all visitors. Implement these best practices today and make your navigation barrier-free!

If you’re ready to take the next step toward digital inclusion, reach out to 216digital to schedule an ADA briefing. We’ll help you assess your website, develop a tailored plan, and guide you through the process of building an online presence that works for everyone. Don’t wait—contact us today and let’s make the internet a more accessible place together.
Greg McNeil

January 24, 2025

How-to Guides

Accessibility, drop-down menus, How-to, WCAG, Web Accessibility, web developers, web development
Accessibility Testing: Prioritize Fixes That Truly Matter
Accessibility can feel like an overwhelming mountain to climb. Every round of accessibility testing uncovers new problems—some obvious, others hidden deep in the code or design. Where do you start when everything seems important? What if you tackle the wrong issue first, leaving users still stuck?

These questions are important, and the answers can transform how your website serves all visitors. This guide isn’t just about fixing problems—it’s about focusing your efforts where they matter most. By exploring WebAIM’s four-level severity framework, you’ll learn how to prioritize issues effectively and make meaningful progress toward an inclusive website. Let’s dive in and figure this out together.

WebAIM’s Four-Level Severity Framework

WebAIM (Web Accessibility in Mind) categorizes accessibility issues into four levels of severity based on their impact on users. These categories help prioritize fixes by focusing on barriers that significantly affect user experience and access.

Critical Issues

Critical issues completely block users from accessing specific parts of your website or performing essential tasks. Addressing these issues should be the highest priority. Examples include:
- Interactive elements, such as buttons or form inputs, that cannot be reached or activated using a keyboard.
- Videos without captions, which exclude users who are deaf or hard of hearing.
- Content that flashes or strobes in a way that could cause seizures for individuals with photosensitive epilepsy.
To prevent these barriers, developers should prioritize using accessible, native HTML elements and perform thorough accessibility testing, including keyboard and screen reader evaluations, during the development process.

Significant Issues

Significant issues do not entirely block access but make interacting with the website cumbersome or frustrating for users. Examples include:
- Missing visual focus indicators, which make it challenging for keyboard users to identify the currently focused element.
- Poor color contrast that makes text difficult to read for users with visual impairments.
These issues disrupt the user experience and should be addressed soon after critical issues to enhance accessibility.

Moderate Issues

Moderate issues require users to expend unnecessary effort or time to navigate and interact with web content but do not entirely impede access. Examples include:
- Lack of properly structured semantic HTML, such as headings and regions, which slows navigation for screen reader users.
- Generic or vague descriptive link text (e.g., “Click here”) that fails to describe the destination or action clearly.
- Animations that lack user controls, making it difficult for some users to focus on other content.
Comprehensive accessibility testing ensures these moderate issues are identified and addressed to improve usability for all users.

Minor Issues

Minor issues do not create significant barriers but contribute to a polished and professional user experience when resolved. Examples include:
- Slight inconsistencies in focus styles for keyboard navigation.
- Overuse of ARIA attributes, such as redundant tabindex values on elements that are already focusable.
While not urgent, fixing minor issues during routine updates demonstrates attention to detail and commitment to accessibility best practices.

Step-by-Step Guide to Prioritizing Accessibility Fixes

Feeling unsure where to start? Don’t worry—you’re not alone. Here’s a simple plan to categorize and tackle accessibility issues step by step:

1. Conduct a Comprehensive Accessibility Audit

Begin by testing your site with tools like WAVE and Lighthouse. Then, complement these results with manual testing—navigate your site with a keyboard, try a screen reader, and zoom your browser window. Automated tools catch many issues, but hands-on testing uncovers usability challenges they miss.

2. Categorize Issues by Severity

Use WebAIM’s framework to prioritize fixes:
- Critical issues should top your list, as they directly prevent access.
- Serious issues come next, addressing significant usability gaps.
- Moderate and minor issues can be grouped for later phases.
A structured approach to accessibility testing ensures the most pressing barriers are resolved first.

3. Consider the Impact on Your Audience

Think about how each issue affects your users. For example, missing alt text on product images affects a wide audience and should take precedence. If you have user feedback, use it to identify pain points that need urgent attention.

4. Focus on High-Traffic and High-Value Pages

Start your efforts where they’ll have the greatest impact:
- Homepage and landing pages.
- Key interaction points like forms or checkout pages.
- Frequently accessed resources such as blogs or FAQs.
By targeting these areas during accessibility testing, you ensure that the improvements benefit the largest number of users.

5. Use a Phased Approach for Moderate and Minor Issues

After resolving critical and serious issues, create a plan for tackling moderate and minor ones. For instance:
- Update heading structures during new content creation.
- Fix descriptive link text during routine content reviews.
Breaking these tasks into smaller phases makes the process manageable and less overwhelming.

6. Test and Retest

After making fixes, conduct accessibility testing again. If possible, involve users with disabilities to confirm your solutions work in real-world scenarios. Their feedback is invaluable and can guide future improvements.

Tools and Techniques for Effective Accessibility Testing

A good mix of tools and techniques ensures you catch both technical and usability issues. Here’s what to try:
- Automated Tools: WAVE and Lighthouse are great for spotting common errors.
- Manual Testing: Use a keyboard or screen reader to experience your site like some users do.
- Color Contrast Checkers: WebAIM’s Contrast Checker ensures text is easy to read.
- User Testing: Working with people who have disabilities provides first hand insights.
Why Prioritization Matters

Prioritizing fixes has clear benefits:
- Faster Results: You can address critical barriers quickly and make your site accessible sooner.
- Better Use of Resources: Time and budget go toward solving high-impact problems.
- Happier Users: Fixing severe issues first improves usability for everyone.
Taking things one step at a time, with regular accessibility testing, makes the process less overwhelming and helps you steadily improve your site.

Final Thoughts

Accessibility can feel like a big undertaking, but it doesn’t have to be. By focusing on the most critical barriers first and conducting consistent accessibility testing, you can make real progress without burning out. Accessibility isn’t a one-time project—it’s an ongoing commitment to creating a better digital experience for all.

Imagine how many more people could enjoy your site if it were accessible to everyone. Whether you’re a developer, IT director, or content creator, each step you take helps make the web a more inclusive place.

And you don’t have to do it alone. 216digital is here to help. From audits to ongoing accessibility testing and monitoring, we’ll guide you every step of the way. Together, we can create a website that’s user-friendly, inclusive, and aligned with the latest standards. Schedule your consultation today, and let’s get started making your site the best it can be!
Greg McNeil

January 21, 2025

How-to Guides

Accessibility, Accessibility testing, automated testing, How-to, WebAIM, Website Accessibility
Accessibility in JavaScript: A Developer’s Guide
JavaScript has revolutionized web development, enabling developers to create interactive and dynamic websites. However, these enhancements can also introduce significant accessibility barriers if not implemented thoughtfully. For web developers and eCommerce managers, ensuring that JavaScript-powered features are accessible isn’t just about compliance—it’s about creating an inclusive experience for all users.

This guide explores the essential techniques, testing methods, and best practices to ensure that JavaScript features meet accessibility standards and improve usability for everyone.

Why Accessibility in JavaScript Matters

Interactive JavaScript elements, such as modals, dropdown menus, and dynamic content updates, can be challenging for users with disabilities. Poorly implemented JavaScript can break keyboard navigation, confuse screen readers, or cause focus management issues, creating barriers that exclude a portion of your audience.

By prioritizing accessibility, developers can:
- Meet Web Content Accessibility Guidelines (WCAG).
- Improve user experience for everyone, including users with disabilities.
- Reduce the risk of legal action related to accessibility non-compliance.
- Expand your website’s audience and customer base.
Common Accessibility Barriers in JavaScript

Before diving into solutions, let’s examine some common accessibility pitfalls associated with JavaScript:
1. Keyboard Inaccessibility: Many JavaScript features rely on mouse interactions, neglecting users who navigate with a keyboard.
2. Focus Management Issues: Improper handling of focus can disorient users, especially when triggering modals, popups, or dynamic content.
3. Unlabeled ARIA Roles: Dynamic elements without proper ARIA roles and attributes can confuse screen readers.
4. Non-Compliant Custom Widgets: Custom components like sliders, tabs, or accordions often fail to replicate the functionality of their native HTML counterparts.
5. Content Updates Without Notifications: Dynamic content changes that are not announced to assistive technologies leave users unaware of critical updates.
Best Practices for Accessible JavaScript

To make your JavaScript-powered features inclusive, follow these best practices:

1. Ensure Keyboard Accessibility

All interactive elements must be operable using only a keyboard. Consider the following:
- Use semantic HTML elements like <button>, <a>, and <input>, which have built-in keyboard support.
- Add tabindex= "0" to custom elements to make them focusable.
- Avoid tabindex values greater than 0, which can disrupt the natural tabbing order.
- Implement custom keyboard interactions for widgets like dropdowns and modals. For example, allow users to close a modal with the Escape key.
2. Manage Focus Properly

Focus management is critical when working with dynamic content. Here’s how to handle it:
- Set Initial Focus: When opening a modal, move focus to the first interactive element within it.
- Trap Focus: Prevent users from tabbing out of an open modal.
- Restore Focus: Return focus to the triggering element when the modal is closed.
- Avoid Focus Loss: Ensure that dynamically added content doesn’t cause focus to disappear.
3. Use ARIA Responsibly

Accessible Rich Internet Applications (ARIA) can enhance screen reader compatibility, but misuse can lead to confusion. Follow these guidelines:
- Use ARIA Roles: Assign roles like role= "dialog" for modals or role= "menu" for dropdowns.
- Add ARIA States: Use attributes like aria-expanded, aria-hidden, and aria-live to convey element states to assistive technologies.
- Don’t Overuse ARIA: Avoid using ARIA when semantic HTML can achieve the same result.
4. Announce Dynamic Content Updates

For screen reader users, dynamically updated content must be announced clearly:
- Use aria-live regions to alert users to changes in content.
- Set the aria-live attribute to “polite” for non-urgent updates or “assertive” for critical changes.
- Avoid excessive announcements, which can overwhelm users.
5. Test Custom Widgets Thoroughly

If you create custom widgets, ensure they mimic the behavior of native elements:
- Use the WAI-ARIA Authoring Practices Guide as a reference.
- Make widgets focusable, operable via keyboard, and compatible with screen readers.
- Test with multiple assistive technologies and devices to ensure broad accessibility.
Testing JavaScript for Accessibility

Accessibility testing is an essential part of development. Use the following tools and methods to identify and address accessibility issues:

Automated Tools
1. Lighthouse (built into Chrome DevTools): Provides a quick audit of accessibility issues.
2. WAVE: Highlights accessibility problems directly on your webpage.
Manual Testing

Automated tools can’t catch every issue, so manual testing is critical:
- Keyboard Navigation: Ensure all interactive elements are focusable and operable with the Tab and Enter keys.
- Screen Readers: Test your website with screen readers like NVDA, JAWS, or VoiceOver.
- Focus Indicators: Verify that focus indicators are visible and intuitive.
Real-World Scenarios

Test your website with users who rely on assistive technologies. User feedback can uncover issues that developers might overlook.

Meeting WCAG Requirements

To comply with WCAG, focus on these key guidelines:

Perceivable
- Ensure text alternatives for images and icons.
- Provide captions for video content.
Operable
- Make all functionality available via a keyboard.
- Avoid content that flashes more than three times per second.
Understandable
- Use clear labels and instructions.
- Ensure consistent navigation and predictable interactions.
Robust
- Use valid HTML and ARIA attributes to ensure compatibility with assistive technologies.
Benefits of Accessible JavaScript

Implementing accessible JavaScript goes beyond compliance. It delivers tangible benefits, such as:
- Improved User Experience: Accessible features make your website easier to use for everyone.
- Increased Market Reach: Approximately 16% of the world’s population lives with some form of disability. Accessibility ensures they can engage with your website.
- Better SEO: Many accessibility improvements, like proper headings and alt text, also enhance search engine rankings.
- Legal Compliance: Meeting accessibility standards helps protect your business from lawsuits and reputational damage.
Conclusion

It is far easier to create accessible JavaScript from the onset rather than trying to fix it as an afterthought if you are armed with the proper knowledge.

Stay informed about evolving standards like WCAG and remain proactive in integrating accessibility into your development workflow. If you’re unsure if your JavaScript is accessible or are looking for an implementation partner who is focused on accessibility, reach out to 216digital using the contact form below.
Greg McNeil

January 17, 2025

How-to Guides

Accessibility, How-to, JavaScript, Web Accessibility, web developers, Website Accessibility
How to Use JAWS for Screen Reader Testing
For millions of people with visual impairments, screen readers like Job Access With Speech (JAWS) are essential for navigating the digital world. According to a 2024 WebAIM survey, JAWS continues to lead the way as one of the most widely used screen readers, with 41% of respondents relying on it—outpacing other tools like NonVisual Desktop Access (NVDA) and Apple VoiceOver.

If you’re focused on building an accessible digital experience, incorporating screen reader testing into your workflow is a must. Not only does it help you create a more inclusive website, but it also supports compliance with accessibility laws like the Americans with Disabilities Act (ADA), WCAG standards, and more.

In this guide, we’ll break down how to use JAWS for accessibility testing, explore essential commands, and share tips for improving your website’s usability. But first, a quick look at what makes it such a powerful tool.

What is JAWS?

JAWS, developed by Freedom Scientific, is a screen reader that converts on-screen text into speech or braille for users who are blind or visually impaired. It allows users to navigate websites, applications, and documents without needing to see the screen.

JAWS is one of the most popular screen readers globally, making it an essential tool for web accessibility testing. By simulating how users rely on assistive technologies, JAWS helps you identify barriers that may prevent someone from fully engaging with your website.

Why is JAWS Essential for Accessibility Testing?

Accessibility testing is about ensuring everyone, regardless of ability, can interact with your website. JAWS plays a vital role in this process because:
- Real-World Simulation: JAWS mimics how many visually impaired users experience the web, allowing you to uncover issues that automated tools might miss.
- WCAG Compliance: Testing with JAWS helps ensure your website complies with the Web Content Accessibility Guidelines (WCAG), a global standard for digital accessibility.
- Improved User Experience: By identifying and fixing accessibility barriers, you create a more inclusive, user-friendly experience for all visitors.
How to Set Up JAWS
1. Download and Install JAWS: Visit the Freedom Scientific website to download JAWS. While it’s a paid tool, a 40-minute free demo mode is available for testing purposes.
2. System Requirements: Ensure your computer meets the system requirements. JAWS works on Windows but does not support macOS directly.
3. Set Up Your Environment: Use headphones to listen while testing so the screen reader’s output doesn’t interfere with other tasks.
4. Familiarize Yourself with the Settings: Spend time exploring the settings menu to adjust speech rate, verbosity, and other preferences.
Key JAWS Commands You Need to Know

Learning a few essential JAWS commands will make testing faster and more effective. Here are some basics to get you started:
- Navigating Headings: Press H to jump to the next heading and Shift + H to go to the previous heading.
- Lists: Press L to move to the next list and I to navigate to individual list items.
- Links: Use Tab to navigate through links or Insert + F7 to bring up a list of all links on the page.
- Forms: Press F to jump to the next form field and Shift + F to go to the previous one.
- Read the Page: Use Insert + Down Arrow to read the page continuously or Arrow Keys for manual reading.
Step-by-Step Guide to Testing Web Accessibility with JAWS

Start with the Homepage

Open your website’s homepage and let JAWS read through it. Check if the content flows logically and whether important elements, like headings and links, are announced correctly.

Test Navigation

Use the Tab key to navigate through links and interactive elements. Ensure focus indicators are visible and links are descriptive (e.g., “Learn More” should specify the action or page it leads to).

Evaluate Headings

Press Insert + F6 to bring up a list of headings. Verify that they are hierarchical and descriptive, making it easier for users to navigate.

Check Forms

Navigate through form fields using the F key. Test for proper labeling, keyboard navigation, and error message announcements.

Test Images and Alt Text

JAWS will read the alt text of images. Ensure images have descriptive alt text and that decorative images are marked appropriately (e.g., as null or empty).

Assess ARIA Roles and Landmarks

Use JAWS to test ARIA roles, landmarks, and live regions. Verify that these elements provide meaningful context to screen reader users.

Document Issues

As you test, document any barriers you encounter, such as missing alt text, unclear link descriptions, or inaccessible forms. Include the steps to replicate the issue and suggest solutions.

Tips for Effective JAWS Testing
- Pair with a Keyboard-Only Test: Ensure your website is fully navigable using only a keyboard, as this is crucial for screen reader users.
- Listen Critically: Pay attention to how JAWS announces content. Confusing or incomplete announcements signal a need for improvement.
- Focus on User Experience: Think about how easy it would be for a JAWS user to accomplish key tasks on your website, such as making a purchase or finding contact information.
- Test Multiple Pages: Don’t stop at the homepage. Test a variety of pages, including forms, product pages, and blogs.
Limitations of JAWS

While JAWS is an invaluable tool for accessibility testing, it has limitations:
- Cost: It is expensive, which may be a barrier for smaller teams or independent developers.
- Learning Curve: The abundance of commands and settings can be overwhelming for beginners.
- Not a Catch-All Solution: JAWS testing alone cannot guarantee accessibility compliance. It’s essential to pair it with other tools and techniques.
Why JAWS Should Be Paired with Other Tools

JAWS provides critical insights, but no single tool can capture all accessibility issues. Consider pairing it with:
- Automated Testing Tools: Tools like WAVE and Lighthouse can quickly identify common issues, such as missing alt text or low contrast.
- Other Screen Readers: Testing with multiple screen readers, such as NVDA or VoiceOver, ensures compatibility across platforms.
- Manual Testing: Involve users with disabilities in your testing process to gain authentic feedback.
Building a More Inclusive Web

Testing your website with JAWS is a powerful step toward creating an inclusive digital environment. By understanding how screen reader users interact with your content, you can uncover barriers and make meaningful improvements. Remember, accessibility is not just about compliance—it’s about creating a web that works for everyone.

While JAWS is a fantastic tool, it should be part of a broader accessibility strategy that includes other tools, user testing, and a commitment to following WCAG guidelines. With the actionable insights from this guide, you’re well on your way to improving your website’s accessibility and making a positive impact on all your users.

Let’s work together to make the web a more inclusive place!

Need help with accessibility testing? If you’re ready to take your accessibility efforts to the next level, 216digital can help. Our team specializes in comprehensive accessibility solutions that go beyond surface fixes. Schedule an ADA briefing with us today by using the contact form below. Let’s work together to make your website accessible to everyone.
Greg McNeil

January 16, 2025

How-to Guides, Testing & Remediation

Accessibility testing, assistive technology, How-to, JAWS, screen readers, user testing
Writing Code for Web Accessibility: A Guide for Developers
Coding often feels like speaking a secret language—it’s complex, intricate, and incredibly rewarding. Including web accessibility in your workflow isn’t about reinventing the wheel; it’s about refining your craft to ensure your work reaches everyone. Accessible code builds on the practices you already know, with small adjustments that make a significant impact. In this guide, we’ll explore actionable steps to help you create accessible, user-friendly websites that leave no user behind.

What Is Accessible Code?

Accessible code ensures everyone can interact with your website, regardless of ability. Following standards like the Web Content Accessibility Guidelines (WCAG) helps create an inclusive space for all users. By integrating accessibility, you’re not just meeting legal requirements but building a better, more welcoming web experience.

Accessibility encompasses several aspects, including:
- Visual Accessibility: Making visual content perceivable by users with visual impairments, often through tools like screen readers.
- Interactive Usability: Ensuring interactive elements work seamlessly with keyboards, touchscreens, or voice commands.
- Content Clarity: Structuring information logically to assist users with cognitive impairments.
- Compatibility: Writing robust code that works with assistive technologies and adapts to future updates.
The Four Golden Rules of Accessibility: POUR

The foundation of accessible code is rooted in WCAG’s four guiding principles: Perceivable, Operable, Understandable, and Robust (POUR). These principles ensure your website is usable for everyone. Let’s break them down:
- Perceivable: Users must be able to see or hear content.
  - Provide text alternatives for non-text content like images (e.g., alt text).
  - Use captions and transcripts for multimedia content.
- Operable: Interactive elements must be usable with any input device.
  - Ensure keyboard navigation works for all features.
  - Include features like skip-to-content links to improve navigation.
- Understandable: Content and interfaces should be easy to comprehend.
  - Label forms clearly and provide concise instructions.
  - Write meaningful error messages that guide users in resolving issues.
- Robust: Code should be compatible with a wide range of assistive technologies.
  - Use valid, semantic HTML to ensure content is interpretable.
  - Test compatibility with assistive technologies like screen readers.
Adhering to these principles ensures compliance with accessibility standards while enhancing usability for everyone.

Best Practices for Writing Accessible Code

Here’s how to apply accessibility principles to your code:

1. Use Semantic HTML

Semantic HTML provides structure and meaning to your content. Elements like <header>, <nav>, <main>, and <footer> improve navigation for screen readers and other assistive technologies.

Instead of:
```
<div onclick="doSomething()">Click me</div>
```
Use:
```
<button onclick="doSomething()">Click me</button>
```
Semantic tags enhance usability and reduce the need for ARIA roles, ensuring better compatibility.

2. Make Forms Accessible

Forms are a common source of frustration for users with disabilities. Pair input fields with <label> tags to provide clear context:
```
<label for="email">Email:</label>
<input type="email" id="email" name="email">
```
For added guidance, use aria-describedby for hints:
```
<p id= "emailHint"> We'll never share your email.</p>
<input type="email" id="email" aria-describedby="emailHint">
```
Additionally:
- Group related fields with <fieldset> and <legend>.
- Include real-time error validation with accessible alerts.
3. Ensure Keyboard Navigation

Interactive elements should be operable using a keyboard. Use logical HTML structures and the tabindex attribute sparingly to create a natural focus order.

Example:
```
<button tabindex="0">Focus me</button>
```
Avoid negative tabindex values unless necessary, as they can disrupt navigation.

4. Add Alt Text to Images

Alt text makes images accessible to screen readers. Describe the content succinctly:
```
<img src= "puppy.jpg" alt= "A golden retriever puppy playing with a ball">
```
If an image is decorative, use an empty alt attribute (alt= "") to skip it for screen readers.

5. Mind Your Colors

Color contrast impacts readability. Use tools like Contrast Checker to verify that text is legible. Avoid using color as the sole means of conveying information. For example:
```
<span style="color: red;">Required field</span>
```
Should also include:
```
<span class="required" aria-label="Required field">*</span>
```
6. Use ARIA Wisely

Accessible Rich Internet Applications (ARIA) roles can enhance functionality but should be used sparingly. Stick to semantic HTML whenever possible. Common ARIA roles include:
- role= "alert" for dynamic notifications.
- aria-expanded for collapsible menus.
- aria-live for real-time updates.
7. Don’t Forget Multimedia

Provide captions for videos and transcripts for audio content. Respect user preferences for reduced motion by using the prefers-reduced-motion media query:
```
@media (prefers-reduced-motion: reduce) {
  animation: none;
}
```
Testing Your Accessible Code

Even the best code needs testing. Use these methods:
- Automated Testing: Tools like Google Lighthouse or WAVE can identify common issues.
- Manual Testing: Navigate your site using only a keyboard or a screen reader (e.g., NVDA, VoiceOver).
- User Testing: Get feedback from users with disabilities to uncover real-world issues.
Testing should be an ongoing part of your development process to catch and fix issues early.

Challenges Developers Face—and How to Overcome Them

Challenge: Understanding WCAG Guidelines Can Be Intimidating

Solution: Start with the essentials. Focus on foundational elements like semantic HTML, alt text, and keyboard navigation. Once these are second nature, dive deeper into more complex guidelines—one step at a time.

Challenge: Debugging ARIA Roles Can Be Tricky

Solution: ARIA can feel like uncharted territory, but tools like ARIA Authoring Practices and automated testing tools (e.g., Google Lighthouse or WAVE) make it manageable. Stick to semantic HTML where possible to minimize the need for custom roles.

Challenge: Maintaining Accessibility During Updates

Solution: Accessibility isn’t a one-and-done task; it’s an ongoing commitment. Make accessibility checks part of your QA process and leverage tools like WAVE to identify issues after every update. Document accessibility practices in your team’s workflow to keep everyone aligned.

Challenge: Balancing Deadlines with Accessibility Goals

Solution: Tight deadlines can pressure teams to deprioritize accessibility. Combat this by integrating accessibility from the start of a project rather than treating it as an add-on. Small, consistent efforts save time in the long run and prevent last-minute fixes.

By acknowledging these challenges and embracing practical solutions, developers can turn obstacles into opportunities to create better, more inclusive websites.

Keep Learning and Building Accessible Code

Web accessibility is a continuous journey—and an exciting one. As developers, we thrive on solving problems and improving our craft, and accessibility is no different. By staying updated with trusted resources like WebAIM, MDN Web Docs, and the A11y Project, you can keep sharpening your skills and pushing the boundaries of what’s possible. Engage with communities, take courses, and embrace every opportunity to learn. Every small step you take makes the web a more inclusive place for everyone.

Writing accessible code is about thoughtful, inclusive choices that enhance user experiences. Start with the basics, make accessibility an integral part of your workflow, and let learning drive your improvements. The impact of your efforts extends far beyond compliance; it creates meaningful connections and opens your work to all users, regardless of ability.

Ready to take your commitment further? Schedule an ADA briefing with 216digital. Our team specializes in tailored web accessibility solutions, helping you mitigate risks and create a more inclusive online presence. Let’s build a better web—together.
Greg McNeil

January 9, 2025

How-to Guides

accessible code, ADA Compliance, How-to, WCAG, web developers, web development
Email Accessibility: Why It Matters for Your Marketing
Did you know that many marketing emails are nearly impossible for some people to read? It’s true! People with disabilities, especially those who use screen readers, often struggle with text that isn’t coded properly or images that don’t have any descriptions. The good news is that email accessibility is simpler than you might think. In this article, we’ll explore why emails can be hard to read for people with disabilities, why you should care, and how you can start making changes today. Let’s dive in!

Why Accessibility in Emails Matters

You might be wondering, “Why should I think about email accessibility?” There are two big reasons:
1. Reach More Readers: Accessibility helps you connect with a larger audience, which means more potential customers.
2. It’s the Right Thing to Do: Many people rely on screen readers or special settings to read their messages, and they deserve the same great experience as everyone else.
Plus, consider this: There are about 61 million adults in the United States alone who have disabilities, and over one million of them are blind. Emails that aren’t accessible can stop them from reading newsletters, buying products, or joining your events. By focusing on accessibility, you’re ensuring everyone can connect with you.

The Business Case for Accessible Emails

You might ask, “Why should I spend my time on email accessibility?” Here are three compelling reasons:
1. Stay Legally Compliant: Laws like the Americans with Disabilities Act (ADA) may apply to online communication. Staying compliant avoids potential legal issues.
2. Expand Your Audience: People with disabilities make up a significant group. Including them ensures your message reaches more people.
3. Improve Content for Everyone: Accessible content benefits all users. For example, larger fonts are easier on the eyes, and descriptive link text helps people skimming emails on their phones.
In short, email accessibility isn’t just nice to have — it’s a smart move that can boost your brand and prevent legal headaches.

Why Marketing Emails Tend To Be Inaccessible

Let’s be honest: emails can be tricky. Here’s why:
- They Rely on Tables for Layout: Modern web pages use advanced CSS layouts, but many email clients don’t support them. This forces developers to use tables, which can confuse screen readers if not coded correctly.
- Limited Support for Buttons: Real <button> elements often aren’t supported. Replacing buttons with images can create accessibility issues if the images lack descriptions.
- Drag-and-Drop Tools Aren’t Perfect: Email builders like Mailchimp or HubSpot can generate messy or incomplete HTML code, leading to hidden accessibility problems.
These challenges make email accessibility tricky, but don’t worry. With a few simple steps, you can overcome these issues.

Building an Accessibility Checklist for Emails

Here’s a simple checklist to help you make your emails more accessible:

Template Setup (One-Time Fixes)
1. Add role=”presentation” to Tables: This attribute tells screen readers to ignore table structure, reducing confusion.
2. Underline Inline Links: Don’t rely on color alone to indicate links. Use underlines to make them easily identifiable.
3. Avoid Using One Big Image as Your Email: Screen readers can’t interpret a single large image. If images are disabled, subscribers will see an empty box instead of your content.
Campaign-Level Fixes
1. Add Alt Text to Every Image: Alt text provides descriptions for images. Keep it brief but clear (e.g., “Model wearing a red winter jacket”).
2. Use Semantic HTML Elements: Use <h1> for main headings, <h2> for subheadings, and <p> for paragraphs to help screen readers understand content structure.
3. Use Descriptive Links: Replace vague link text like “Click Here” with “View our winter jackets” to provide context.
Testing and QA for Your Accessible Emails

How can you ensure your emails are accessible? Test them!

Manual Testing

Use free screen readers like NVDA (Windows) or VoiceOver (Mac) to hear how your email sounds. Listening to your email read aloud is a great way to catch problems.

Automated Testing Tools

Use tools like Google Lighthouse or WAVE to scan your email’s web version for issues. Publish a temporary version, get the URL, and analyze it for errors.

A/B Testing

Test different versions of your accessible emails to see what resonates best with your audience. Compare engagement metrics to measure the impact of accessibility.

Accessibility Best Practices for Email Design

Here are additional tips for email accessibility:
1. Make It Mobile-Friendly: Ensure text, buttons, and layouts work well on smaller screens.
2. Choose Readable Fonts and Colors: Use high contrast (e.g., black text on a white background) and avoid tiny fonts.
3. Avoid Flashing or Moving Text: Fast-moving elements can be challenging for some users. Use animation sparingly.
Encouraging a Culture of Accessibility

Once you start focusing on accessibility, share your knowledge with your team:
1. Offer Mini-Trainings: Show marketing and design teams how to add alt text or check code for issues.
2. Collaborate with Developers: Work with your development team to address tricky code problems.
3. Celebrate Wins: Highlight successful accessible campaigns during team meetings to encourage continued focus.
Conclusion

Email accessibility matters because it helps people with disabilities, grows your audience, and enhances your brand’s reputation. The best part? It doesn’t have to be complicated. With simple steps like adding alt text, using descriptive links, and making your designs mobile-friendly, you can create emails that everyone can enjoy.

Take a moment to review your next email draft. Is there alt text? Are links descriptive? Are fonts readable? If so, you’re already ahead of many marketers. Keep going, and soon accessibility will become a natural part of your email marketing process, benefiting both your audience and your brand
Greg McNeil

January 3, 2025

How-to Guides, The Benefits of Web Accessibility

Accessibility, email accessibility, How-to, Web Accessibility, web developers
Making Hidden Content Accessible to Assistive Technologies
As a web developer, you want your website to be usable by everyone, including people who rely on assistive technologies. These technologies—such as screen readers, braille displays, and speech recognition software—can help individuals with disabilities navigate the web more easily. Sometimes, you may need to hide certain parts of your webpage visually without hiding them from these tools. However, doing this incorrectly can cause big accessibility issues.

In this article, we’ll explore how to effectively hide and manage hidden content for people using assistive technologies. We’ll discuss why display: none is problematic, how to use the clip pattern, and how attributes like aria-hidden and hidden can help. By the end, you’ll have a better understanding of how to ensure your website remains inclusive and user-friendly.

The Problem with display: none

When you use display: none in your CSS, you remove an element from the visual flow of the page. This means sighted users will not see it. But, it also means the element is completely invisible to assistive technologies such as screen readers. If you’ve hidden important text or controls this way, users who rely on assistive technologies might miss out on content or functionality that they need.

For example, imagine you have a button that visually looks like an icon, but you hide the text label using display: none. Now, people who can see the icon know what the button does, but people using assistive technologies hear nothing. This creates a poor user experience and makes your site less accessible.

The Clip Pattern: A Better Approach

To visually hide content while keeping it available to assistive technologies, the clip pattern is a popular solution. The idea is to position the element off-screen so sighted users don’t see it, but screen readers can still find it. Here’s an example:
```
.visually-hidden {
  position: absolute;
  width: 1px;
  height: 1px;
  margin: -1px;
  padding: 0;
  border: 0;
  overflow: hidden;
  clip: rect(0, 0, 0, 0);
  white-space: nowrap;
}
```
By applying the .visually-hidden class to your element, you ensure it’s hidden visually but remains accessible to assistive technologies. This makes the content discoverable by screen readers, letting users who can’t see the screen still benefit from it.

Why the Clip Pattern Works

This pattern relies on moving the element so it’s not visible in the viewport and restricting its size to 1px by 1px. With clip: rect(0, 0, 0, 0); (or clip-path in modern CSS), the browser cuts off any visual display. Yet, the element remains in the Document Object Model (DOM), meaning assistive technologies can still access it. That’s the key difference between this and display: none.

Managing Visibility with aria-hidden and the hidden Attribute

Beyond CSS, there are HTML and ARIA (Accessible Rich Internet Applications) attributes that also control how content is shown to both users and assistive technologies. Two important attributes here are aria-hidden and the HTML5 hidden attribute.

aria-hidden="true"

When you add aria-hidden="true" to an element, you’re telling assistive technologies not to read or announce that element to users. This is handy for decorative images or redundant content. For instance, if you have a background image that doesn’t provide important information, you could mark it with aria-hidden="true" so screen readers ignore it.

But be cautious: if you need an element to be read by assistive technologies, do not use aria-hidden=”true”. This attribute will block that element from being announced entirely.
```
<div aria-hidden="true">
  <img src="decorative-image.jpg" alt=""/>
</div>
```
HTML5 hidden Attribute

The hidden attribute is another way to remove content from everyone—both sighted users and assistive technologies. When you use it, browsers typically hide the element. Screen readers will also skip it. This is good if the element is meant to be inaccessible to all users, like a form section that’s not yet relevant or a menu item that’s not available.
```
<div hidden>
  <p>This content is hidden from all users.</p>
</div>
```
Use hidden or aria-hidden when you truly want to exclude an element from assistive technologies. If you want it hidden visually but still available to screen readers, you should stick with the clip pattern or .visually-hidden approach.

Best Practices for Accessible, Visually-Hidden Content

1. Use Semantic HTML

Using proper semantic HTML elements (like <nav> for navigation, <main> for main content, or <section> for thematic grouping) is important for clear structure. It helps assistive technologies interpret your content correctly. Semantic HTML also reduces the need for extra attributes and complex styling, since the markup itself conveys meaning.

2. Avoid Hiding Focusable Elements

If an element can receive focus (like links, form inputs, or buttons), think carefully before hiding it. A hidden yet focusable element can be confusing for keyboard-only users, since it might get focus without being visible. If you must hide a focusable element, consider removing it from the tab order by using tabindex="-1" or ensuring it’s properly revealed at the right time.

For example, if you have a pop-up form that appears only after a button click, you can initially hide it with the clip pattern. Once the user clicks, you can remove the clip pattern or switch the CSS to show the content. This way, the form becomes available to both sighted users and people using assistive technologies at the same time.

3. Provide Context for Hidden Content

Sometimes you want to reveal hidden content dynamically (like a drop-down menu). In these cases, use ARIA attributes such as aria-expanded and aria-controls to inform assistive technologies that a certain part of the page is now visible or hidden. This can help screen reader users understand changes on the page.
```
<button aria-expanded="false" aria-controls="menu" id="menuButton">
  Toggle Menu
</button>

<nav id="menu" class="visually-hidden">
  
</nav>
```
When you click the button, you can toggle its aria-expanded value from false to true, and remove the .visually-hidden class from the menu. This ensures that both visual and non-visual users know the content has been revealed.

4. Test with Multiple Assistive Technologies

It’s important to test your website with different assistive technologies because each one may behave slightly differently. Popular screen readers include NVDA, JAWS, and VoiceOver. Don’t forget to check on both desktop and mobile devices. Regular testing can help you catch accessibility issues before your users do.

Handling Localization

If you’re translating your site into multiple languages, remember that hidden text might also need translation. For example, your .visually-hidden text for instructions or links should be available to screen readers in every supported language. Make sure your language attributes (like lang="en") are correct, and consider cultural differences that could impact how you label hidden elements.

For instance, if you have an English site and a Spanish site, your hidden instructions should be translated into Spanish on the Spanish version. This ensures that users relying on assistive technologies can access the content in the correct language.

Putting It All Together: A Quick Example

Let’s look at a simple example of an accessible button that has visually hidden text:
```
<button class="icon-button">
  <span class="visually-hidden">Submit Form</span>
  <img src="icon-submit.png" alt="" aria-hidden="true" />
</button>
```
- The .visually-hidden class hides the text “Submit Form” from sighted users, but screen readers can still read it.
- The <img> tag includes an empty alt attribute and aria-hidden="true", so assistive technologies ignore the image itself.
- Sighted users see only the icon, while screen reader users hear “Submit Form.”
This example keeps your content accessible to people using assistive technologies and also meets visual design needs.

Additional Resources
- Web Content Accessibility Guidelines (WCAG): A detailed guide on making web content accessible.
- WAI-ARIA Authoring Practices: Official tips on using ARIA roles, states, and properties.
- MDN Web Docs on ARIA: In-depth explanations of ARIA attributes and best practices.
Exploring these resources will help you master hiding content effectively, ensuring people who use assistive technologies can still access everything they need.

Conclusion

Hiding content from sighted users while keeping it accessible to assistive technologies is an essential skill for modern web developers. By avoiding display: none for important information, using the clip pattern for visually hidden content, and carefully leveraging aria-hidden or hidden, you can ensure everyone has a good experience on your site.

Remember to keep the following points in mind:
1. Use the clip pattern (.visually-hidden) to hide content from sighted users but keep it readable by assistive technologies.
2. Use aria-hidden and hidden only when you truly want to hide content from all users, including those using assistive technologies.
3. Pay attention to focusable elements, making sure you don’t accidentally trap keyboard users in hidden sections.
4. Test frequently with various tools and real users to ensure your hidden content behaves as you expect.
5. Localize your hidden text so that people using assistive technologies in other languages can also benefit.
By following these guidelines, you’ll be well on your way to building inclusive websites that work for everyone. Your careful attention to accessibility shows that you value all your users, regardless of their abilities or the assistive technologies they use. Embracing these practices will help ensure a positive, welcoming, and user-friendly experience across the board.
Greg McNeil

December 31, 2024

How-to Guides

Accessibility, assistive technology, How-to, web developers, web development, Website Accessibility
Keyboard Navigation: A Guide to Accessible Web Testing
Have you ever tried using the internet without a mouse?

For millions of people, that’s not just a thought experiment—it’s how they navigate the internet every day. Whether it’s because of physical limitations, visual impairments, or using assistive tech, the keyboard is their main tool. But here’s the thing: if your website doesn’t work smoothly with a keyboard, you’re not just creating a frustrating experience—you’re leaving people behind.

So, how does your site stack up? Let’s dive into why keyboard navigation matters and how it plays a key role in building an accessible web.

Why Keyboard Navigation Matters

Keyboard navigation is a lifeline for users who can’t rely on a mouse due to physical limitations, visual impairments, or the use of assistive technologies. Moreover, it’s an excellent starting point for testing overall web accessibility. If your website works seamlessly with a keyboard, you’re likely on track to create an inclusive experience for all users.

How to Navigate a Website with Keyboard Shortcuts

Before you start testing your website’s accessibility, it’s helpful to understand the most common keyboard shortcuts users rely on. These shortcuts allow people to move through links, buttons, forms, and other interactive elements.
- Tab Key: Moves focus to the next interactive element.
- Shift + Tab: Moves focus to the previous element.
- Enter or Spacebar: Activates a focused element, such as clicking a link or button.
- Arrow Keys: Scroll through pages or navigate dropdown menus.
- Escape (Esc): Closes modals, dropdowns, or pop-ups.
- Ctrl + F: Opens a search bar (in most browsers) to find specific content on the page.
For Mac users on Safari, enabling full keyboard navigation is a quick adjustment:
1. Open Safari Preferences.
2. Go to the Advanced tab.
3. Check the box next to “Press Tab to highlight each item on a webpage.”
With these basics in mind, you’re ready to put your website to the test.

Testing Your Website for Keyboard Navigation

Keyboard testing doesn’t require fancy tools—just a keyboard, a browser, and a little know-how. Follow this step-by-step guide to evaluate your site’s accessibility.

Start with the Basics: Can You Navigate Without a Mouse?

Unplug your mouse and navigate through your homepage and other key pages using only the keyboard. Can you access all essential features and content?

Check Focus Indicators

Focus indicators are crucial for users who rely on visual cues. As you use the Tab key, ensure there’s a visible outline around the element currently in focus. Check for the following:
- The focus indicator is easy to see and contrasts well with the background.
- The focus moves logically through elements in the order they appear on the page.
If the focus jumps around or disappears, it creates a frustrating experience for users.

Test Interactive Elements

Interactive elements like buttons, links, and form fields should be fully accessible. Specifically:
- Can you submit a form using the Enter or Spacebar key?
- Can you open and close modals or dropdown menus with the keyboard?
- Do navigation menus function seamlessly?
Verify Skip Navigation Links

Skip navigation links allow users to bypass repetitive elements, like menus, and jump straight to the main content. To check this:
- Ensure the skip navigation link is present and functional.
- Verify it’s one of the first focusable elements when using the Tab key.
Watch Out for Keyboard Traps

Keyboard traps occur when users get stuck in an element, like a modal or widget, and can’t move forward. Ensure users can exit these areas by pressing the Escape key or tabbing out.

Tips for Better Keyboard Navigation

Creating an accessible website doesn’t happen by accident. Here are a few tips to enhance keyboard navigation for all users:
- Design with Focus in Mind: Use CSS to style focus outlines for clarity and visibility. Avoid removing focus outlines entirely.
- Ensure Logical Focus Order: Use semantic HTML (e.g., <button> and <a>) and avoid custom elements that might disrupt natural focus flow.
- Leverage ARIA Roles and Labels: Use ARIA (Accessible Rich Internet Applications) roles and labels to make custom components like sliders or dropdowns keyboard accessible.
- Test Regularly: Accessibility is not a one-and-done task. Regular testing ensures your website stays accessible as it evolves.
Common Challenges and How to Address Them

Even with the best intentions, challenges may arise. Here are some common issues and solutions:
- Invisible Focus: Use the :focus pseudo-class in CSS to style interactive elements for better visibility.
- Complex Widgets: Components like carousels or accordions can lack keyboard support. Build these elements with accessibility in mind or use accessible libraries.
- Poorly Labeled Links: Ensure all links and buttons have clear, descriptive text or labels so users know what action they’ll perform.
Why Focus on Keyboard Navigation?

Beyond accessibility, testing your website for keyboard navigation improves overall user experience and usability. Keyboard accessibility is often a foundation for ensuring compatibility with screen readers and other assistive technologies. If your website works well for a keyboard user, it’s likely on its way to meeting broader accessibility standards like WCAG 2.1.

Next Steps: Make Your Website Keyboard-Accessible

Keyboard navigation is more than just a best practice—it’s a cornerstone of inclusive design that invites everyone to participate fully on the web. By ensuring your site is keyboard-accessible, you create a welcoming experience for users of all abilities, reinforce your brand’s commitment to accessibility, and lay a strong foundation for broader ADA compliance.

If you’re ready to take the next step toward digital inclusion, reach out to 216digital to schedule an ADA briefing. We’ll help you assess your website, develop a tailored plan, and guide you through the process of building an online presence that works for everyone. Don’t wait—contact us today and let’s make the internet a more accessible place together.
Greg McNeil

December 24, 2024

How-to Guides, Testing & Remediation

Accessibility testing, keyboard accessibility, Keyboard Navigation, User Experience, Web Accessibility
How to Test a Website for Accessibility
Making sure your website works for everyone, including people with disabilities, isn’t just the right thing to do—it’s essential. Accessibility testing helps you find and fix issues that could make your site tough to use for people with visual, hearing, cognitive, or mobility impairments. Whether you’re a web developer, IT pro, or content creator, knowing how to test for accessibility can save you headaches—and money—later.

In this guide, we’ll cover some simple, effective ways to check your site’s accessibility. Don’t worry; you don’t need to be an expert to get started. Let’s dive in!

Why Website Accessibility Testing Matters

Accessibility testing ensures your website is welcoming to everyone, regardless of their abilities. It also helps you stay in line with important standards like the Web Content Accessibility Guidelines (WCAG) and legal requirements like the Americans with Disabilities Act (ADA).

But it’s not just about compliance—it’s about creating a better experience for all your users. For example:
- Clear, organized content helps screen readers and makes reading easier for everyone.
- Good color contrast improves visibility, whether you’re in bright sunlight or a dim room.
- Keyboard-friendly navigation benefits people who can’t use a mouse and even power users who prefer shortcuts.
Accessibility doesn’t just check a box—it enhances your site for everyone.

Quick Accessibility Testing Methods

You don’t need a deep dive into the world of accessibility to start testing your website. There are three main ways to test:
1. Automated Testing
2. Manual Testing
3. Assistive Technology Testing
Each method offers unique insights. Using them together? That’s your golden ticket to a more accessible site.

Automated Accessibility Testing

Automated tools are perfect for a quick scan. They flag common issues like missing alt text, messy headings, or poor color contrast. Think of them as a helpful starting point, not the end-all solution.

Here are a few tools to get you started:
- WAVE (Web Accessibility Evaluation Tool): This browser extension highlights issues like missing alt text and improper ARIA attributes. Bonus: It’s free and super easy to use.
- Google Lighthouse: Built right into Chrome’s DevTools, it gives your site an accessibility score and helpful feedback.
- WebAIM’s Contrast Checker: This tool ensures your text and background colors meet WCAG’s contrast requirements.
Pro Tip: Automated tools are great, but they’re not perfect. They might miss subtler issues or flag things that aren’t actually problems. Treat them as step one, not the whole process.

Manual Accessibility Testing

Sometimes, you need a human touch. Manual testing simulates real-world user experiences to catch what tools can’t.

Try These Tests:
- Keyboard Navigation Test:
  - Use the Tab key to move around your site. Can you access every link, button, and form?
  - Is there a visible focus indicator (like a highlight) on selected elements?
  - Does the navigation flow make sense?
  - If you can’t complete tasks like filling out a form or navigating menus, there’s work to do.
- Color Contrast Test:
  - Use WebAIM’s Contrast Checker to make sure your text is easy to read against its background.
  - Aim for a 4.5:1 contrast ratio for normal text and 3:1 for large text (18px or larger).
- Alt Text for Images:
  - Check your images. Does the alt text describe their content or purpose?
  - Decorative images? They should have empty alt text (e.g., alt=””).
- Forms and Error Messages:
  - Are form labels clear?
  - Do error messages explain what went wrong and how to fix it?
For further details on manual testing, please read our article “The Human Touch: Manual Testing for Web Accessibility.”

Testing with Assistive Technologies

If you want the real deal, test your site with the tools your users rely on. Screen readers like NVDA (NonVisual Desktop Access) offer invaluable insights into how accessible your site really is.

What to Check:
- Is the content reading in a logical order?
- Are links clear and descriptive?
- Does alt text accurately describe images?
Testing with assistive tech gives you a firsthand look at your site’s usability.

Common Accessibility Issues to Watch For

As you test, keep an eye out for these usual suspects:
- Missing or unhelpful alt text.
- Low color contrast.
- Skipped heading levels (like jumping from H2 to H4).
- Keyboard traps where navigation gets stuck.
- Forms without labels or clear error messages.
- No visible focus indicators for buttons or links.
The Limitations of Quick Tests

Quick tests are awesome for a first pass, but they won’t catch everything. For example:
- They might miss problems with interactive elements or dynamic content.
- They don’t always account for users with cognitive disabilities.
For a deeper dive, consider a professional audit. Experts can evaluate your site with advanced tools, manual reviews, and assistive tech to ensure you’re fully WCAG-compliant.

Why Overlays Aren’t the Solution

You might’ve seen tools promising quick fixes with overlays or widgets. Sounds tempting, right? But these “solutions” often create more problems than they solve.

Here’s Why Overlays Fall Short:
- They don’t address underlying code issues.
- They can clash with screen readers and other assistive technologies.
- They frustrate users instead of helping them.
Real accessibility starts with your site’s design and development, not a temporary patch.

Wrapping It Up: A Holistic Approach to Accessibility

Testing your website for accessibility doesn’t have to be overwhelming. By starting with automated tools like WAVE or Google Lighthouse and layering in manual checks for keyboard navigation, color contrast, and assistive technology testing, you can create a more inclusive experience for all users.

But remember, quick tests are just the beginning. Regular testing and professional audits ensure your website meets accessibility standards and provides the best possible user experience.

If you’re ready to take your accessibility efforts to the next level, 216digital can help. Our team specializes in comprehensive accessibility solutions that go beyond surface fixes. Schedule an ADA briefing with us today by using the contact form below. Let’s work together to make your website accessible to everyone.
Greg McNeil

December 16, 2024

How-to Guides, Testing & Remediation

Accessibility, Accessibility Remediation, Accessibility testing, Web Accessibility Remediation, Website Accessibility

What Is ARIA (and Why Does It Matter)?

Why Semantic HTML Should Be Your First Choice

What is Semantic HTML?

Why Does it Matter?

Real-world Example

When (and Why) ARIA Is Actually Needed

Filling the Gaps

Roles, States, and Properties

Example: Tabs and sliders

The Most Common ARIA Mistakes (and Why They’re a Problem)

Misusing Roles

Example

Redundant or Conflicting Roles

Example

Incorrect State Management

Example

ARIA Overload

Example

Misusing aria-hidden

Example

Why “No ARIA” is Often the Best Choice

Best Practices for Using ARIA the Right Way

Use Native HTML First

Example

Be Precise with Roles and States

Example

Don’t Add ARIA Where It’s Not Needed

Example

Test with Real Assistive Tech

Conclusion

Need Help with Web Accessibility?

Foundational Accessibility Principles for Drop-Down Menus

1. Use Semantic HTML

2. Ensure Keyboard Navigation

3. Use ARIA Roles and Attributes Wisely

Structuring Accessible Drop-Down Menus

1. Toggling Visibility

2. Managing Focus for Keyboard Users

3. Enabling Smooth Keyboard Interactions

Testing Your Drop-Down Menus for Accessibility

1. Screen Reader Testing

2. Keyboard Testing

3. Contrast and Readability

Best Practices for Creating Intuitive Menus

Conclusion

WebAIM’s Four-Level Severity Framework

Critical Issues

Significant Issues

Moderate Issues

Minor Issues

Step-by-Step Guide to Prioritizing Accessibility Fixes

1. Conduct a Comprehensive Accessibility Audit

2. Categorize Issues by Severity

3. Consider the Impact on Your Audience

4. Focus on High-Traffic and High-Value Pages

5. Use a Phased Approach for Moderate and Minor Issues

6. Test and Retest

Tools and Techniques for Effective Accessibility Testing

Why Prioritization Matters

Final Thoughts

Why Accessibility in JavaScript Matters

Common Accessibility Barriers in JavaScript

Best Practices for Accessible JavaScript

1. Ensure Keyboard Accessibility

2. Manage Focus Properly

3. Use ARIA Responsibly

4. Announce Dynamic Content Updates

5. Test Custom Widgets Thoroughly

Testing JavaScript for Accessibility

Automated Tools

Manual Testing

Real-World Scenarios

Meeting WCAG Requirements

Perceivable

Operable

Understandable

Robust

Benefits of Accessible JavaScript

Conclusion

What is JAWS?

The Problem with `display: none`

Managing Visibility with `aria-hidden` and the `hidden` Attribute

`aria-hidden="true"`