Master vocabulary for screen readers, keyboard navigation, captions, and text resize. Beginner
0 / 25 completed
1 / 25
The developer is testing with NVDA + Firefox.
What type of assistive technology is NVDA?
NVDA (NonVisual Desktop Access) is a free, open-source Windows screen reader. Screen readers are among the most widely used assistive technologies:
Screen reader
Platform
Best paired browser
NVDA
Windows (free)
Firefox / Chrome
JAWS
Windows (enterprise)
Chrome / Firefox
VoiceOver
macOS / iOS (built-in)
Safari
TalkBack
Android (built-in)
Chrome
Key vocabulary: "screen reader", "speech output", "Braille display", "browse mode vs. forms mode", "virtual buffer".
2 / 25
An accessibility test plan includes "keyboard-only navigation testing".
What does this mean?
Keyboard-only testing validates SC 2.1.1 Keyboard (Level A) — all functionality must be operable without a mouse:
Key
Action
Tab
Move focus to the next interactive element
Shift+Tab
Move focus to the previous interactive element
Enter / Space
Activate focused button or control
Arrow keys
Navigate within widgets (menus, radios, tabs)
Escape
Close modals, dismissing overlays
Common fails: focus traps, mouse-only event handlers (onmouseover with no keyboard equivalent), invisible focus. Key vocabulary: "Tab order", "keyboard trap", "focus management", "keyboard operability (SC 2.1.1)".
3 / 25
The video has captions but no audio description.
What is the difference between captions and audio description?
Captions and audio descriptions serve different disability groups and are governed by separate WCAG success criteria:
Feature
Serves
WCAG criterion
Captions
Deaf / hard-of-hearing users
SC 1.2.2 — Level A
Audio description
Blind / low-vision users
SC 1.2.5 — Level AA
Captions ≠ subtitles: captions include non-speech audio cues (e.g., "[door slams]", "[music playing]"). Audio description narrates visual content not conveyed by existing audio. Key vocabulary: "closed vs. open captions", "SDH (Subtitles for Deaf and Hard-of-hearing)", "extended audio description".
4 / 25
The mobile app should be tested with an increased text size setting.
Which disability does large text accommodation primarily support?
Low vision users need enlarged content but typically interact visually — they are not the same as blind screen reader users:
User
Primary tool
WCAG criterion
Blind
Screen reader (NVDA, JAWS)
SC 1.3.1, 4.1.2 etc.
Low vision
Screen magnification, large text, high contrast
SC 1.4.4 Text Resize (200%)
SC 1.4.4: text must resize up to 200% without loss of content or functionality. Use relative font units (rem/em) not px. Key vocabulary: "low vision", "Dynamic Type (iOS)", "text resize (200%)", "relative font units", "zoom vs. text resize".
5 / 25
The engineering team was told to avoid using accesskey attributes.
Why are access keys problematic?
The accesskey HTML attribute assigns single-keystroke shortcuts to elements. The conflicts make them harmful rather than helpful:
Conflict type
Example
Screen reader shortcuts
NVDA uses single letter keys (H for headings, L for links)
WCAG 2.1 SC 2.1.4 (Character Key Shortcuts, AA): single-character shortcuts must be remappable, disabled, or only active on focus. Key vocabulary: "access key conflict", "keyboard shortcut remapping", "SC 2.1.4".
6 / 25
During a code review of a new form component, Sarah notices that the `
Properly associating `
7 / 25
During a PR review for a new API endpoint designed to handle user profile updates, David points out that the response doesn't include a clear error message when validation fails. Maria argues that the client-side JavaScript already handles errors and displays an appropriate message. What is the *most* important reason why the server-side API should also return a detailed error object?
While client-side error handling is important for user experience, a standardized error object at the API level provides crucial information for developers to diagnose and fix issues. This includes status codes, specific validation errors (e.g., invalid email format), and potentially debugging details. Returning this structured data ensures that errors aren't silently ignored or misinterpreted during automated testing or in other systems consuming the API.
8 / 25
curl -X GET https://api.example.com/users/123
During a standup update, Alex mentions that the API response for user retrieval doesn't include any information about the user's accessibility settings. Ben argues that this isn't a problem because the frontend application already handles displaying those settings to the user based on their profile preferences. Which of the following best describes why including accessibility setting data in the API response is crucial?
The core principle of accessibility is about providing a consistent experience tailored to individual needs. Including user-specific accessibility settings in the API response allows the frontend to dynamically adapt the UI and functionality based on those preferences—ensuring that all users receive an accessible experience, regardless of their device or browser. Options 1 & 4 focus on performance optimizations which are secondary to the core goal; option 3 highlights a crucial aspect of centralized data management for accessibility.
9 / 25
David is reviewing a new feature for an e-commerce website. The feature allows users to filter products by various criteria, including 'color'. During the review, he identifies that the color filters don't have ARIA attributes and are only accessible via keyboard navigation. Maria suggests simply adding `role='button'` to each filter option. What's the biggest issue with Maria's proposed solution from an accessibility perspective?
Maria's solution only addresses basic functionality but doesn't solve the core issue: screen readers need semantic information to understand and announce the color filters. The correct answer highlights that ARIA roles lack the necessary meaning for assistive technology; they don't tell a screen reader *what* these elements are or how to interact with them. Adding role='button' is a common mistake, but it doesn't address the fundamental need for proper semantic markup for accessibility.
10 / 25
John and Maria are discussing a new web component that provides dynamic updates to user profiles. John notes that the component uses `MutationObserver` to track changes. Maria suggests this is unnecessary complexity, arguing that simpler event listeners would suffice. Which of the following best explains why using a `MutationObserver` in this scenario is crucial for accessibility?
The core issue here isn't performance (though that's a factor). Assistive technologies, like screen readers, often modify the DOM structure dynamically to announce changes. Event listeners only fire when *the user* directly interacts with an element; they won't be triggered by these assistive technology updates. `MutationObserver` specifically monitors for changes to the DOM tree itself, ensuring that the component reacts instantly to any modifications made by screen readers or other assistive tools – which is essential for a truly accessible experience.
11 / 25
During a code review of a new form component, Sarah notices that the `
Properly associating `
12 / 25
During a PR review for a new API endpoint designed to handle user profile updates, David points out that the response doesn't include a clear error message when validation fails. Maria argues that the client-side JavaScript already handles errors and displays an appropriate message. What is the *most* important reason why the server-side API should also return a detailed error object?
While client-side error handling is important for user experience, a standardized error object at the API level provides crucial information for developers to diagnose and fix issues. This includes status codes, specific validation errors (e.g., invalid email format), and potentially debugging details. Returning this structured data ensures that errors aren't silently ignored or misinterpreted during automated testing or in other systems consuming the API.
13 / 25
curl -X GET https://api.example.com/users/123
During a standup update, Alex mentions that the API response for user retrieval doesn't include any information about the user's accessibility settings. Ben argues that this isn't a problem because the frontend application already handles displaying those settings to the user based on their profile preferences. Which of the following best describes why including accessibility setting data in the API response is crucial?
The core principle of accessibility is about providing a consistent experience tailored to individual needs. Including user-specific accessibility settings in the API response allows the frontend to dynamically adapt the UI and functionality based on those preferences—ensuring that all users receive an accessible experience, regardless of their device or browser. Options 1 & 4 focus on performance optimizations which are secondary to the core goal; option 3 highlights a crucial aspect of centralized data management for accessibility.
14 / 25
David is reviewing a new feature for an e-commerce website. The feature allows users to filter products by various criteria, including 'color'. During the review, he identifies that the color filters don't have ARIA attributes and are only accessible via keyboard navigation. Maria suggests simply adding `role='button'` to each filter option. What's the biggest issue with Maria's proposed solution from an accessibility perspective?
Maria's solution only addresses basic functionality but doesn't solve the core issue: screen readers need semantic information to understand and announce the color filters. The correct answer highlights that ARIA roles lack the necessary meaning for assistive technology; they don't tell a screen reader *what* these elements are or how to interact with them. Adding role='button' is a common mistake, but it doesn't address the fundamental need for proper semantic markup for accessibility.
15 / 25
John and Maria are discussing a new web component that provides dynamic updates to user profiles. John notes that the component uses `MutationObserver` to track changes. Maria suggests this is unnecessary complexity, arguing that simpler event listeners would suffice. Which of the following best explains why using a `MutationObserver` in this scenario is crucial for accessibility?
The core issue here isn't performance (though that's a factor). Assistive technologies, like screen readers, often modify the DOM structure dynamically to announce changes. Event listeners only fire when *the user* directly interacts with an element; they won't be triggered by these assistive technology updates. `MutationObserver` specifically monitors for changes to the DOM tree itself, ensuring that the component reacts instantly to any modifications made by screen readers or other assistive tools – which is essential for a truly accessible experience.
16 / 25
During a code review of a new form component, Sarah notices that the `
Properly associating `
17 / 25
During a PR review for a new API endpoint designed to handle user profile updates, David points out that the response doesn't include a clear error message when validation fails. Maria argues that the client-side JavaScript already handles errors and displays an appropriate message. What is the *most* important reason why the server-side API should also return a detailed error object?
While client-side error handling is important for user experience, a standardized error object at the API level provides crucial information for developers to diagnose and fix issues. This includes status codes, specific validation errors (e.g., invalid email format), and potentially debugging details. Returning this structured data ensures that errors aren't silently ignored or misinterpreted during automated testing or in other systems consuming the API.
18 / 25
curl -X GET https://api.example.com/users/123
During a standup update, Alex mentions that the API response for user retrieval doesn't include any information about the user's accessibility settings. Ben argues that this isn't a problem because the frontend application already handles displaying those settings to the user based on their profile preferences. Which of the following best describes why including accessibility setting data in the API response is crucial?
The core principle of accessibility is about providing a consistent experience tailored to individual needs. Including user-specific accessibility settings in the API response allows the frontend to dynamically adapt the UI and functionality based on those preferences—ensuring that all users receive an accessible experience, regardless of their device or browser. Options 1 & 4 focus on performance optimizations which are secondary to the core goal; option 3 highlights a crucial aspect of centralized data management for accessibility.
19 / 25
David is reviewing a new feature for an e-commerce website. The feature allows users to filter products by various criteria, including 'color'. During the review, he identifies that the color filters don't have ARIA attributes and are only accessible via keyboard navigation. Maria suggests simply adding `role='button'` to each filter option. What's the biggest issue with Maria's proposed solution from an accessibility perspective?
Maria's solution only addresses basic functionality but doesn't solve the core issue: screen readers need semantic information to understand and announce the color filters. The correct answer highlights that ARIA roles lack the necessary meaning for assistive technology; they don't tell a screen reader *what* these elements are or how to interact with them. Adding role='button' is a common mistake, but it doesn't address the fundamental need for proper semantic markup for accessibility.
20 / 25
John and Maria are discussing a new web component that provides dynamic updates to user profiles. John notes that the component uses `MutationObserver` to track changes. Maria suggests this is unnecessary complexity, arguing that simpler event listeners would suffice. Which of the following best explains why using a `MutationObserver` in this scenario is crucial for accessibility?
The core issue here isn't performance (though that's a factor). Assistive technologies, like screen readers, often modify the DOM structure dynamically to announce changes. Event listeners only fire when *the user* directly interacts with an element; they won't be triggered by these assistive technology updates. `MutationObserver` specifically monitors for changes to the DOM tree itself, ensuring that the component reacts instantly to any modifications made by screen readers or other assistive tools – which is essential for a truly accessible experience.
21 / 25
During a code review of a new form component, Sarah notices that the `
Properly associating `
22 / 25
During a PR review for a new API endpoint designed to handle user profile updates, David points out that the response doesn't include a clear error message when validation fails. Maria argues that the client-side JavaScript already handles errors and displays an appropriate message. What is the *most* important reason why the server-side API should also return a detailed error object?
While client-side error handling is important for user experience, a standardized error object at the API level provides crucial information for developers to diagnose and fix issues. This includes status codes, specific validation errors (e.g., invalid email format), and potentially debugging details. Returning this structured data ensures that errors aren't silently ignored or misinterpreted during automated testing or in other systems consuming the API.
23 / 25
curl -X GET https://api.example.com/users/123
During a standup update, Alex mentions that the API response for user retrieval doesn't include any information about the user's accessibility settings. Ben argues that this isn't a problem because the frontend application already handles displaying those settings to the user based on their profile preferences. Which of the following best describes why including accessibility setting data in the API response is crucial?
The core principle of accessibility is about providing a consistent experience tailored to individual needs. Including user-specific accessibility settings in the API response allows the frontend to dynamically adapt the UI and functionality based on those preferences—ensuring that all users receive an accessible experience, regardless of their device or browser. Options 1 & 4 focus on performance optimizations which are secondary to the core goal; option 3 highlights a crucial aspect of centralized data management for accessibility.
24 / 25
David is reviewing a new feature for an e-commerce website. The feature allows users to filter products by various criteria, including 'color'. During the review, he identifies that the color filters don't have ARIA attributes and are only accessible via keyboard navigation. Maria suggests simply adding `role='button'` to each filter option. What's the biggest issue with Maria's proposed solution from an accessibility perspective?
Maria's solution only addresses basic functionality but doesn't solve the core issue: screen readers need semantic information to understand and announce the color filters. The correct answer highlights that ARIA roles lack the necessary meaning for assistive technology; they don't tell a screen reader *what* these elements are or how to interact with them. Adding role='button' is a common mistake, but it doesn't address the fundamental need for proper semantic markup for accessibility.
25 / 25
John and Maria are discussing a new web component that provides dynamic updates to user profiles. John notes that the component uses `MutationObserver` to track changes. Maria suggests this is unnecessary complexity, arguing that simpler event listeners would suffice. Which of the following best explains why using a `MutationObserver` in this scenario is crucial for accessibility?
The core issue here isn't performance (though that's a factor). Assistive technologies, like screen readers, often modify the DOM structure dynamically to announce changes. Event listeners only fire when *the user* directly interacts with an element; they won't be triggered by these assistive technology updates. `MutationObserver` specifically monitors for changes to the DOM tree itself, ensuring that the component reacts instantly to any modifications made by screen readers or other assistive tools – which is essential for a truly accessible experience.
What will I practice in "Assistive Technology Vocabulary | Accessibility Exercises"?
This is an Accessibility Language exercise set. It walks through 25 scenario-based multiple-choice questions built around real usage of Accessibility Language terminology that IT professionals encounter on the job.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free to complete with no account, sign-up, or paywall.
How many questions are in this exercise?
This set contains 25 questions. Each one shows immediate feedback and a detailed explanation after you answer, so you learn the correct usage right away rather than waiting for a final score.
Do I need prior experience to complete this exercise?
No prior experience is required. Each question includes a full explanation covering the reasoning behind the correct answer, so the exercise itself teaches the Accessibility Language vocabulary as you go.
Can I retry the exercise if I get questions wrong?
Yes — use the "Try again" button on the results screen to reset your answers and go through all the questions again. There is no limit on attempts.
Is my progress saved?
Your answers and score for the current session are tracked in the browser as you go. No account or login is needed, and there is nothing to install.
What if I don't understand a term used in a question?
Read the explanation shown after you answer each question — it breaks down the correct term in plain English with a real-world example. You can also check the site Glossary for quick definitions.
How is this different from reading a blog article on the topic?
Exercises like this one are interactive drills that test and reinforce specific vocabulary through multiple-choice questions, while blog articles explain concepts in prose. Practising here after reading builds active recall, not just passive recognition.
Where can I find more Accessibility Language exercises?
See the Accessibility Language exercises hub for the full set of related pages, or browse all exercise categories from the main Exercises index.
Can I use this exercise to prepare for a technical interview?
Yes — Accessibility Language vocabulary comes up often in technical discussions and interviews. Pair this exercise with our dedicated Interview Preparation section for role-specific practice.