On Demand Webinar: User Centered Testing with User Journeys
The post On Demand Webinar: User Centered Testing with User Journeys appeared first on TPGi — a Vispero company.
The post On Demand Webinar: User Centered Testing with User Journeys appeared first on TPGi — a Vispero company.

The post Weekly Reading List October 13 2025 appeared first on TPGi — a Vispero company.

There are many semantic HTML tags covered under WCAG SC 1.3.1: Info and Relationships, but in this article, we’ll zoom in on one of the most misunderstood, the table.
You might be thinking: “Do we really need tables when we already have semantic tags like lists?”
It’s a valid question. Lists (<ul>, <ol>, <dl>) are fantastic for presenting structured information, but when data grows beyond a simple one-to-one relationship, tables step in as the powerhouse.
Imagine you want to display personal details. Using a description list, the information looks clean and simple:
<h2>Personal Details</h2>
<dl>
<dt>Full Name</dt>
<dd>Tom Henry</dd>
<dt>Date of Birth</dt>
<dd>01-Jan-1999</dd>
<dt>Gender</dt>
<dd>Male</dd>
<dt>Country</dt>
<dd>Australia </dd>
<dt>Company</dt>
<dd>Google</dd>
</dl>
It would look like this:

That’s great for a single person’s data. But what if you have multiple people’s details?
A list would stretch the page endlessly, making it harder for users (especially screen reader users) to locate specific information. This is where a table becomes the clear winner:
<table>
<thead>
<tr>
<th>Full Name</th>
<th>Date of Birth</th>
<th>Gender</th>
<th>Country</th>
<th>Company</th>
</tr>
</thead>
<tbody>
<tr>
<td>Tom Henry</td>
<td>01-Jan-1999</td>
<td>Male</td>
<td>Australia</td>
<td>Google</td>
</tr>
<tr>
<td>Stifen Watson</td>
<td>02-Jan-2000</td>
<td>Male</td>
<td>U.S.</td>
<td>TPGi</td>
</tr>
</tbody>
</table>
This will look like:

Now, the same information is organized in rows and columns. Users can scan by column (e.g., find all employees from India) or by row (see all details of one person) in an instant.
A well-structured table is more than just rows and cells. For screen readers and other assistive technologies, the right markup tells the story:
The data table’s semantic structure is already explained in the Tables Tutorial | Web Accessibility Initiative (WAI) | W3C. but just to be on the same page, here’s the basic concept of defining a data table:
<table> defines the table<tr> defines each row.<td> holds the data.<th> indicates headers. Column headers are defined together as a row of <th> elements, while row headers are defined as a single <th> within each row of <td>.This semantic structure allows assistive technologies to announce relationships like: “Date of Birth, 01-01-2000.” Instead of just reading “01-01-2000” without context.
When there’s only one table on a page, users usually know what it represents. But if you have multiple tables, things get tricky.
For example, screen reader might announce both tables simply as: “Table with 3 rows and 5 columns.”


Confusing, right?
That’s why naming tables is important. You can do this using the <caption> element:
<table>
<caption>2025 Employees Details</caption>
...
</table>
<table>
<caption>2024 Employees Details</caption>
...
</table>


Problem solved! Users now know exactly what each table represents.
Alternatively, aria-label or aria-labelledby can also be used to define the label for the table.
<table aria-label=”2024 Employees Details”>
...
</table>
If a table is complex or requires extra explanation, you can add an aria-describedby attribute to provide a short description. This helps screen reader users understand the table’s purpose and structure before navigating through its data.
<p id="tableDesc">
This table provides employee details, including department, role, and seminar participation status for 2024.
</p>
<table aria-describedby="tableDesc">
...
</table>
“Table with 4 columns and 2 rows. This table provides employee details, including department, role, and seminar participation status for 2024. Column l, Row 1 Employee Name”

“Table with 2 rows and 4 columns This table provides employee details, including department, role, and seminar participation status for 2024.”

summary property served a similar purpose in earlier HTML versions, but it is now deprecated in HTML5. While some assistive technologies may still recognize it, it’s best practice to use aria-describedby for long-term compatibility.
A layout table is a table used purely for visual arrangement of content rather than for presenting data. In layout tables, there is no meaningful relationship between cells, and the table is only used for decorative or structural purposes.
Layout tables are acceptable in WCAG and can be used to arrange page elements such as headers, sidebars, and footers. However, this approach works visually, but it introduces accessibility challenges. Screen readers and other assistive technologies interpret tables semantically — announcing rows, columns, and headers — which can confuse users when no real data relationship exists.
For this reason, table markup should not be used for page design or visual layout.
Assistive technologies depend on table elements like <th> and <caption> to announce structure and meaning. Including these in layout tables misleads users by suggesting relationships that don’t actually exist.
For layout tables, avoid:
headers attributescope attributesummary attribute<th> element<caption> elementAlthough WCAG does not prohibit the use of layout tables, CSS-based layouts are strongly recommended to preserve the proper semantic meaning of HTML table elements. When a table is used purely for layout, the <th> element, headers attribute, and scope attribute should not be used, since there is no actual relationship between data cells.
Likewise, the <caption> element and summary attribute should not be used, as they are intended to provide descriptions for data tables, not layout structures.
<table>
<tbody>
<tr>
<td colspan="2" >
<h1>Header Area</h1>
</td>
</tr>
<tr>
<td>
<p>Sidebar content goes here. <br>Links or navigation. </p>
</td>
<td>
<p>Main page content goes here. <br>This is where the main article, text, or image would be placed. </p>
</td>
</tr>
</tbody>
</table>
When read by a screen reader, this table is treated as layout-only, and table structure is ignored.
“heading level 1 Header Area. Sidebar content goes here. Links or navigation. Main page content goes here. This is where the main article, text, or image would be placed.”


If your markup is long and complex, the easiest way to confirm whether a table is being treated as a layout table is to inspect the accessibility tree. In such cases, you’ll see the table identified as a “LayoutTable” rather than a semantic data table.

Alternatively, role="presentation" or role="none" can be applied to remove the semantic meaning of a table from the accessibility API, even if elements like <table> or <th> are present.
<table role=”presentation”>
...
</table>
With this approach, the entire table structure is ignored in the accessibility tree, and only the actual content inside the table is exposed to assistive technologies.

Tables often contain large amounts of data, which can make them difficult to view on smaller screens. While many developers try to make tables “fit” by hiding columns or reflowing them into lists, these approaches can break relationships between data cells and headers.
A simple and effective way to handle this is to make the table scrollable horizontally.
<div style="overflow-x: auto;">
<table>
...
</table>
</div>

The overflow-x: auto; property allows users to scroll horizontally when the table width exceeds the viewport.
In my opinion, tables are one of the most powerful semantic tools in HTML, but they’re also among the most misunderstood. While lists and other tags can handle simple cases, tables shine when it comes to organizing and presenting complex datasets. A well-structured table does more than group information—it creates meaningful relationships between data and headers, making content more accessible for everyone, especially users of assistive technologies.
At the same time, tables should never be misused for layout purposes. Layout tables may still “work” visually, but can introduce barriers when screen readers announce them as data. By choosing semantic HTML elements appropriately and relying on CSS for layout, developers can create content that is both visually appealing and accessible to all users.
The post Tables: Beyond Rows and Columns appeared first on TPGi — a Vispero company.

TagThe post Weekly Reading List October 6 2025 appeared first on TPGi — a Vispero company.

For anyone developing accessible digital content, keeping up with changes to the Web Content Accessibility Guidelines (WCAG) is essential. One of the more notable updates in WCAG 2.2 is the removal of Success Criterion (SC) 4.1.1: Parsing.
This article explains what SC 4.1.1 covered, why it was removed, how it affects accessibility in practice, and which criteria now address issues once covered by parsing.
Parsing errors, such as invalid or poorly structured markup, were once a significant concern because they could affect how assistive technologies interpreted a webpage. Earlier, assistive technologies sometimes performed their own parsing, which made them more vulnerable to broken markup. Since WCAG 2.0 was published, however, both web specifications (such as HTML) and browsers have greatly improved in handling these errors.
Today, assistive technologies rely on the browser’s interpretation of markup rather than doing their own parsing. Because of this, most parsing errors no longer create real barriers for users, which is why SC 4.1.1 was made obsolete in WCAG 2.2.
SC 4.1.1 was originally included to encourage valid, well-structured markup. Its removal does not mean that writing clean code is unimportant; rather, it acknowledges that this requirement is no longer necessary because modern browsers and assistive technologies handle parsing errors far more reliably.
Under WCAG 2.1, SC 4.1.1 required:
The aim was to ensure that assistive technologies and browsers could interpret content reliably, improving both accessibility and interoperability.
WCAG 2.2 removed SC 4.1.1 for several reasons:
Many parsing issues no longer create real barriers for assistive technology users.
Example:
<div>
<p>Hello, world
<--missing </div> and </p> -->
This markup triggers a validator error, but browsers typically auto-correct it, and therefore assistive technologies will interpret it correctly.
Real-world issues tied to invalid markup are better addressed under other criteria:
When SC 4.1.1 was introduced, browsers and assistive tech often broke on stray tags or invalid nesting. Today, both are far better at handling minor syntax errors, so these issues rarely block access.
Removing SC 4.1.1 helps WCAG focus on accessibility issues that affect users directly, instead of minor coding mistakes that don’t cause real problems.
Although most parsing errors no longer block accessibility, some mistakes can still cause real problems when they affect element relationships, accessible names, roles, or focus order. These issues are now handled under other Success Criteria rather than SC 4.1.1.
Every id attribute in a document is required to be unique. Problems caused by duplicates depend on context:
<label for="id"> may associate with the wrong input, causing screen readers to announce incorrect or confusing information. aria-labelledby, aria-controls, or aria-describedby may fail, breaking the link between elements and leaving users without instructions.id may direct users to the wrong location or confuse screen reader navigation.Relevant SCs: 1.3.1 Info and Relationships, 1.3.2 Meaningful Sequence, 2.4.3 Focus Order, 2.4.4 Link Purpose, 4.1.2 Name, Role, Value, 2.5.3 Label in Name
Interactive elements (like <a>, <button>, <input>, <select>) should not be nested inside one another.
Example:
<a href="#">:
<button>Click Me</button>
</a>>
Risks include:
Relevant SCs: 2.4.3: Focus Order, 4.1.2: Name, Role, Value
Errors like unclosed elements or misplaced tags generally do not block access today because modern browsers can handle them. However, issues arise when they disrupt:
Example:
<ul>
<li>First item
<li>Second item
</div> <!-- Stray closing div -->
Risks include:
Relevant SCs: 1.3.1: Info and Relationships, 4.1.2: Name, Role, Value
Example:
<label>First Name</label>
<input type="text" id="firstName">
Since there’s no for linking the label to the input, screen readers may not announce it when focus enters the field, confusing users relying on assistive technology or voice input.
Relevant SCs: 1.3.1: Info and Relationships, 4.1.2: Name, Role, Value
To ensure accessible experiences under WCAG 2.2:
The removal of SC 4.1.1 from WCAG 2.2 marks a shift from syntax enforcement to user-centered accessibility. Clean code remains a best practice, but WCAG now emphasizes whether users with disabilities can access, perceive, and operate digital content.
Developers should continue to:
By prioritizing real user experience over strict validator compliance, we can build more inclusive and usable digital environments.
References
The post Understanding the Removal of 4.1.1 Parsing in WCAG 2.2 appeared first on TPGi — a Vispero company.

prefers-reduced-motion, and don’t assume everyone’s device can handle complex animations.zoom was fairly simple: allow developers to visually expand or shrink any given element.px and rem for spacing.The post Weekly Reading List September 29 2025 appeared first on TPGi — a Vispero company.
This article describes an approach for creating accessible Flip Cards — small blocks of content designed to resemble a playing card or business card, or similar two-sided thing. They have front and back “faces” and can be “flipped” with a 3D rotation effect.
There are many existing scripts and libraries that implement this effect, but none I’ve found have good enough accessibility, and not for want of trying. Creating an accessible pattern for this was challenging.
The front and back faces are separate blocks of content within a parent container, using transform and perspective to create the appearance of a two-sided card that turns on its vertical axis. This is quite easy to make, but quite hard to make accessible, because there aren't any ARIA semantics that fit the pattern.
Screen reader users need accessible state information, so they know when the card is flipped, and which side is currently shown. However we can't use ARIA state attributes to provide this information, simply because there aren't any valid choices. States like aria-expanded or aria-pressed are not applicable, because they don't mean the same thing — the card is never expanded or collapsed, never pressed or not pressed — the behavior and presentation just aren't equivalent.
The button that triggers the flip could be used to provide accessible feedback, by changing the button's label or description. However dynamically changing a button's content isn't conveyed by screen readers, unless it's also accompanied by a semantic state change … which we can't use!
ARIA live regions are not a suitable replacement here, because they're only appropriate for status updates, not state information.
Without an ARIA state change, the most reliable way to make screen readers announce a button, is to programmatically focus() it. But in order to do that, the button first has to lose focus, yet we can't use blur() because that resets the focus position back to the top of the page, causing screen readers to re-announce the page summary (e.g., the title and main heading).
Focus has to go somewhere, and it has to go somewhere that won't be announced:
The button's label has values like Flip to back
and Flip to front
, which denote its current action. State information is provided by the accessible description, such as Now showing the front
or Now showing the back
. The label and description are both announced when the button is programmatically focused.
Overall, this combination of dynamic label and description provides a functional label, a dynamic state update, and a persistent state summary.
The content of each card face can be any valid HTML, there are no explicit requirements or restrictions. However the surrounding markup is very specific, and must have the following node structure and required attributes:
<div id="MyID" role="group" aria-labelledby="MyID_1">
<aside hidden>
<span id="MyID_1">Flip Card</span>
<span id="MyID_2">Flip to front</span>
<span id="MyID_3">Flip to back</span>
<span id="MyID_4">Now showing the front</span>
<span id="MyID_5">Now showing the back</span>
</aside>
<div>
<button hidden aria-describedby="MyID_1"></button>
<div>
<!-- default content on the front face -->
</div>
<div>
<!-- flipped content on the back face -->
</div>
</div>
</div>
The <div>, <aside>, and <span> elements don't have to use those tags, any valid elements can be used. However their attributes must be as specified, and the button must be a <button>.
<div id="MyID" role="group" aria-labelledby="MyID_1">
The group container needs role="group" to provide a semantic context. The role doesn’t imply any other meaning or functionality, only that everything inside it is part of the same “thing”.
The aria-labelledby attribute defines the group’s accessible name, and must reference the id of the first language data element.
The group id is used in the demo as an identifier for the FlipCard constructor, and a syntactical namespace for other IDs.
<aside hidden>
<span id="MyID_1">Flip Card</span>
<span id="MyID_2">Flip to front</span>
<span id="MyID_3">Flip to back</span>
<span id="MyID_4">Now showing the front</span>
<span id="MyID_5">Now showing the back</span>
</aside>
The language container must include the hidden attribute, which prevents it from being visibly rendered or present in the accessibility tree (equivalent to display:none in the user agent stylesheet, so it doesn’t rely on author CSS to remain hidden).
The five child elements define individual language strings. They must have id attributes, and they must be defined in the same order:
This content is not intended to be shown or directly announced, it only serves as reference data for aria-labelledby or aria-describedby, or to be parsed by the script in order to generate dynamic labels.
<div>
...
<div>
<!-- default content on the front face -->
</div>
<div>
<!-- flipped content on the back face -->
</div>
</aside>
The parent container provides a positioning context, and defines the perspective size for 3D transforms:
{
perspective: 64rem;
position: relative;
}
The first face element is considered to be the front, and is displayed by default. The faces can contain any valid markup, including interactive elements, but it’s recommended to start each one with a heading (e.g., <h2> or <h3> as applicable to the page structure).
<button hidden aria-describedby="MyID_1"></button>
The flip button’s hidden attribute is removed by the script, and exists only to hide the button when scripting is unavailable or hasn’t loaded yet.
The aria-describedby attribute must reference the id of the first language data element. This will be dynamically updated when the card state changes, however iOS/VoiceOver doesn’t support those dynamic description updates, therefore the static value is necessary to provide some fallback context for users, as to what the button’s action is referring to.
The button’s accessible name is also maintained by scripting, defined using aria-label, and rendered with CSS pseudo-content to provide a visible label:
button::before {
content: attr(aria-label);
}
This approach provides more flexibility when styling the flip button, and since the values it’s derived from are already present as in-page text, there are no translation issues with using aria-label in this case.
The flip card has two static states — the front face is displayed, or the back face is displayed — and it flips between them by using transition to animate rotational transform on the faces' container.
This requires two separate transforms. If we only applied rotation to the container, then flipping from front to back would result in the back face being reversed (like a mirror image). But if we also apply rotation to the back face itself, then they cancel each other out by the end of the transition:
@media (prefers-reduced-motion: no-preference) {
[data-flip-state] {
perspective: 64rem;
}
[data-flip-state] > .faces {
transform: rotateY(0deg);
transition: transform 0.5s;
}
[data-flip-state~="flipped"] > .faces {
transform: rotateY(180deg);
}
[data-flip-state] > .faces > .back {
transform: rotateY(180deg);
}
}
Most flip card implementations use absolute positioning and fixed dimensions, where the faces are stacked on top of each other and visibly rotate together. However that means the content can't be responsive to changes in font-size or text spacing, which might cause the layout to reflow and make one or both faces overflow the container.
This pattern does something different to avoid that problem — the two card faces are never displayed at the same time — so they don't need fixed dimensions or absolute positioning, they can freely adapt to reflow, and they don't even have to be the same size.
The trick here is that the displayed face changes in the middle of the transition (when rotation is 90°), which is not visually apparent because neither face is visible for that precise moment (like looking at the side of a playing card).
The demo uses class names for each container element, but these are not required or even identified by the script, so you can do whatever you want:
<div class="card">
...
<div class="faces">
...
<div class="front">
...
</div>
<div class="back">
...
</div>
</div>
</div>
The script provides a dynamic [data-flip-state] attribute, which can be used as an attribute selector for state-dependent styling. For example, the following rule controls which face is currently displayed:
[data-flip-state~="front"] > .faces > .back,
[data-flip-state~="back"] > .faces > .front {
display: none;
}
This attribute has four possible token values, and at any given moment it might have multiple tokens:
| Token | Meaning |
|---|---|
"front" |
The front face is currently displayed. |
"back" |
The back face is currently displayed. |
"flipped" |
The card is flipped to its back face. |
"busy" |
The card is currently transitioning between states. |
Flipping from front to back will pass through the following states:
"front""front flipped busy""back flipped busy""back flipped"Whereas flipping from back to front will do the reverse:
"back flipped""back busy""front busy""front"The demo stylesheet uses pseudo-content to create a visible label from the button's aria-label attribute:
.faces > button::before {
content: attr(aria-label);
}
This approach is recommended for the sake of accessible visual affordance — it clearly conveys the function to sighted users, and also provides a command cue for speech recognition. Users can press the button with a spoken command like Click flip to front
(which still works without a visible label, but then how would they know what to say). However that provision is not absolutely critical, since users have other ways to reach and interact with controls (e.g., using the Show Numbers
function in Voice Control for macOS and iOS).
One alternative presentation could be to use an icon, or an empty dot-like button:
.faces > button {
border-radius: 1rem;
height: 1rem;
width: 1rem;
}
.faces > button::before {
content: none;
}
Another possibility is to style the button so it's completely transparent and covers the entire card.
In this case it's essential to prevent the button from receiving pointer events, otherwise it wouldn't be possible to select text or interact with the card content. For sighted keyboard users, it will seem as though the card itself is in the focus order, while the button's action is still effectively available to pointer users, since they can also trigger a flip by clicking the card:
.faces > button {
background: transparent;
border: none;
border-radius: 0.6rem;
height: 100%;
margin: 0;
pointer-events: none;
width: 100%;
}
.faces > button::before {
content: none;
}
.faces > button:disabled {
filter: none;
opacity: 1;
}
The focus hook is the element that receives focus during a card transition. The focus hook isn't announced or visibly displayed, but its :focus-visible state is used to maintain the flip button's outline, when the button itself isn't focused:
.card > [tabindex="-1"]:not([hidden]) {
display: inline-block;
overflow: hidden;
pointer-events: none;
position: absolute;
z-index: -1;
}
.card > [tabindex="-1"]:focus {
outline: none;
}
[tabindex="-1"]:focus-visible + .faces > button {
outline: 0.15rem solid var(--outline-color);
outline-offset: 0.15rem;
}
If you're making significant changes to the flip card's structural styling, then it may be helpful to make the focus hook temporarily visible, to confirm that its layout position is correct, for example:
.card > [tabindex="-1"]:not([hidden]) {
background: rgba(255,0,0,0.25);
outline: 0.3rem solid #f00;
z-index: 1;
}
The FlipCard class is structured as an export module, or you can convert it to a regular class declaration if that's preferred. Any number of instances can exist on a single page, each of which is created using the FlipCard constructor:
const demo = new FlipCard("#demo");
The argument is a selector query, that specifies a single group container element.
Pointer users can trigger a flip by clicking the whole card, however this could potentially conflict with events on other interactive content (e.g., buttons or links inside the card). To avoid that problem, the whole-card click only applies if the pointer target isn't an interactive element, as specified by a second argument to the FlipCard constructor:
const demo = new FlipCard("#demo", "a[href], button, input");
The argument is a selector query, that should specify any interactive elements the card might contain (or defaults to "button" if undefined).
So whole-card clicks are conditionally ignored, if the pointer target is (or is inside) any element that matches the specified selector. They're also ignored if the pointer action resulted in text selection.
The displayed face changes in the middle of the transition, so we have to monitor the transform in real-time to know when it reaches that point. It needs to look like we're viewing two sides of the same card, and any obvious display swap would undermine that illusion.
This information is not provided by native APIs (CSS transitions and animations don't provide a frame event), but we can create a custom method to monitor their changes, with a combination of requestAnimationFrame() and getComputedStyle().
The following code retrieves the matrix3d string from computed style, converts it to a DOM Matrix, then calculates the rotation angle in degrees:
const matrix = new DOMMatrixReadOnly(this.css.getPropertyValue('transform'));
const rotation = Math.acos(matrix.a) * (180 / Math.PI);
This is called from a function triggered by requestAnimationFrame(), which is very unlikely to ever occur at precisely 90°, so we check for the point when it's only just greater or less, depending on the flip direction:
if((flags.back && rotation >= 90) || (flags.front && rotation <= 90)) {
//swap the displayed face
}
Else if it's not close enough, then iterate again on requestAnimationFrame(), until it is.
This is a bit of a hack! But it's logically sound, semantically valid, and more to the point — it works.
Depending on the screen reader (they all vary in this respect), focusing an empty element would cause the parent group to be re-announced, or the element announced as blank
, and this could still occur even with whitespace-only text content. Whitespace is still required so that the element isn't empty, but its announcement behavior can be overridden by defining an aria-roledescription that can't be announced.
This is achieved with a unicode non-character, which is technically not supposed to exist in a document at all. It's designed to be used programmatically for things like parsing delimiters, but the specification expects them to not be removed if any are present. It's impossible to announce, because it isn't mapped to a character, and the end result is that nothing is announced:
<span role="note" aria-roledescription="" tabindex="-1"> </span>
With thanks to Aditya Jainapur, Hans Hillen, Ricky Onsman, Doug Abrams, Tj Squires, and Isabel Holdsworth, for their useful ideas and feedback during development. I welcome any thoughts, ideas, or feedback you might have on the concepts and solutions, or anything else.
Here are the demos and codebase links again:
Image credit: Resource Database.
The post Creating a truly accessible Flip Card appeared first on TPGi — a Vispero company.

The post Weekly Reading List September 22 2025 appeared first on TPGi — a Vispero company.

The post Weekly Reading List September 15 2025 appeared first on TPGi — a Vispero company.
The post On Demand Webinar: Agile and Accessible User Experiences with AT User Flow Testing appeared first on TPGi — a Vispero company.
Accessibility testing is only as accurate as the screen reader you test against. The September release aligns JAWS Inspect with the latest JAWS screen reader update and updates to ARIA handling which improves how content is announced on the web.
In addition, optional AI tools like FSCompanion now support testers in understanding how content is interpreted by the screen reader.
New to accessibility testing? Keep reading for a tip on how to get started.
Here are some of the updates to JAWS screen reader, and how it affects real-world testing:
Explore What’s New in JAWS to learn more.
If you’re new to accessibility testing, JAWS Inspect and FSCompanion can help you interpret screen reader output with confidence.
For example: If you’re running a report in JAWS Inspect and you see output like “heading level 2” or “link: Products” but aren’t sure why JAWS announces it that way. Then, open FSCompanion and ask: “Why does JAWS say ‘heading’ before some text?” or “What does JAWS use to detect a link?”
FSCompanion will explain how JAWS interprets roles, semantics, and accessible names, giving testers fast context for the speech output shown in JAWS Inspect reports. It’s not for learning how to use JAWS Inspect itself, but it’s a valuable companion when you’re trying to understand what you’re seeing and hearing.
And what does JAWS use to detect a link? According to FSCompanion:
JAWS detects a link on a web page by looking for specific HTML elements that are coded as links, such as the “A” (anchor) tag. When JAWS encounters a link, it announces “Link” and reads the link text. JAWS uses the following information to identify and speak about links:
By default, JAWS reads the screen text of the link, but you can change this in JAWS settings to use the Title or Tooltip if you prefer.
To quickly find and move to links on a web page, you can use the following keystrokes:
Press Tab or Shift+Tab to move between links.
Press Insert+F7 (JAWSKey+F7) to display a list of all links on the current page.
Together, this pairing offers a fast, accurate way to debug accessibility without needing to run JAWS directly.
Ready to learn how screen reader users are experiencing your website? Schedule a demo now.
The post JAWS Inspect September 2025 Update appeared first on TPGi — a Vispero company.
The post Join Vispero at the 2025 M-Enabling Summit appeared first on TPGi — a Vispero company.

aria-activedescendant.
.The post Weekly Reading List September 8 2025 appeared first on TPGi — a Vispero company.