ARIA and Real World Dangers
Dennis Deacon: When applied correctly, ARIA is invaluable. Think of it as asphalt for the potholes in HTML.
Baby Steps Accessibility – PDFs
Dennis Deacon: unless you’ve been creating accessible PDFs for years, chances are most of your files are not accessible.
Testing Methods: Reflow
Dennis Deacon: content can be presented without loss of information or functionality, and without requiring scrolling in two dimensions.
Human Censored Design
Liz Jackson & Rua Williams: Inclusive Design was created to systematize — the extraction of disabled ideas.
HTMHell Advent Calendar
Manuel Matuzović: Any topic or piece of HTML code you love that improves accessibility, performance … Submit ideas by October 1.
Liquid Glass: Apple, you know better
Nat Tarnoff: Update 9.26.25 – Apple has iOS 26.1 in developer beta and some of the concerns about Liquid Glass are being addressed.
Web Accessibility Audit Buyer’s Guide
Microassist: Not to put too fine a point on it, but a web accessibility audit is important because accessibility is important.
The Web’s Most Tolerated Feature
Mike Pennisi: The idea behind zoom was fairly simple: allow developers to visually expand or shrink any given element.
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:
An invisible element is positioned and sized directly behind the button;
When the button is pressed, focus shifts to this invisible element, which isn't announced because it has no conveyable content;
Meanwhile, the button's accessible label and description are updated;
Then the button is focused again, and this triggers its re-announcement.
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>.
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 firstlanguage data element.
The group id is used in the demo as an identifier for the FlipCard constructor, and a syntactical namespace for other IDs.
Language data
<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:
Group name.
Button label to flip the card to its front face.
Button label to flip the card to its back face.
Button description when the front face is displayed.
Button description when the back face is displayed.
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.
Card faces
<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).
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 firstlanguage 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:
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:
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 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:
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:
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:
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:
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:
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:
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:
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.
Like to be notified about more articles like this? Subscribe to the Knowledge Center Newsletter. It not only gives you summaries and links to our technical blog posts but also TPGi webinars, podcasts, and business blog posts – as well as accessibility and web tech conferences and other events, and a reading list of other relevant articles. You get one email a month, it’s free, requires just your email address, and we promise we won’t share that with anyone. Check the archive.
Testing Methods: Images of Text (No Exception)
Dennis Deacon: Text must be displayed using real text, not images of text, so it can be resized, styled, and read by assistive technologies.
The writer, the text and the audience
Hidde de Vries: To understand art, we need to look at more than the artifact, the book, the album, the written text, the poem.
A Quick Primer on Accessible Pagination
Karl Groves: pagination is one of those UI patterns that can be surprisingly nuanced when it comes to accessibility.
Podcast: Crystal Preston-Watson
ASX Chat: from self-taught coder and journalism dropout to Senior Digital Accessibility Analyst at Salesforce’s Office of Accessibility.
Meet the team: Catriona Morrison
Tetralogical: an Accessibility Specialist at TetraLogical, where she focuses on accessibility assessments and testing.
Resource: Accessible Escape Room
Now in kit form, teams of 3-10 people, with or without disabilities, try to solve puzzles while learning about accessibility.
What is NVDA? And why is it important?
Vision Ireland: [JAWS] is expensive, increasingly so as a result of its new subscription model. The main alternative to JAWS is a screen reader called NVDA.
Firefox Release Notes 143.0
Firefox: Firefox now supports Windows UI Automation, which improves support for accessibility tools such as Windows Voice Access, Text Cursor Indicator and Narrator.
Open Source the Revolution
Leah Reich: In order for a human to speak computer, a human has to learn new languages, ones a computer can understand and process.
Join Vispero at the 2025 M-Enabling Summit
TPGi: “Digital Accessibility Innovation—A Deep Dive into Next-Generation User Experiences”, October 6 to 8 in Arlington, Virginia.
Book: Inclusive Design for Accessibility
With contributions from twelve accessibility leaders, this book is for digital designers, developers, UX professionals, product managers, and business leaders committed to inclusive design.
Testing Methods: Visual Presentation
Dennis Deacon: ensure that users can control and adjust the visual presentation of text to improve readability and accessibility
What to expect in WCAG 3.0
Diana Khalipina: WCAG 3.0 is being designed to be more human-centered, more flexible.
WCAG 3 September 2025 Update
Rachael Bradley Montgomery: The question everyone is likely asking is “When will WCAG 3 be complete?”
Update project WP A11y Docs August 2025
Rian Rietveld: the brainstorm session about the content; new contributors that joined in; the work planned for September 2025; how you can help.
Robots to assess city accessibility in Irvine
University of California: self-evaluation of public facilities uses robots to collect data on the accessibility of the city’s streets.
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.
JAWS Update Overview
Here are some of the updates to JAWS screen reader, and how it affects real-world testing:
FSCompanion Updates: FSCompanion, the AI-powered assistant for JAWS, now responds faster and delivers clearer answers. It’s especially useful when interpreting what appears in JAWS Inspect reports. Try it at FSCompanion.ai.
ARIA and Web Behavior Fixes: JAWS now announces ARIA table headers, labels, and form field states more consistently, redundant or unexpected output. These refinements are reflected in JAWS Inspect reports, helping testers catch subtle differences in how components are introduced and grouped.
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:
The visible text on the link (screen text).
The HTML Title attribute, if present.
Tooltip text from the “OnMouseOver” attribute, if available.
ARIA roles and attributes that indicate a link.
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.
Start Testing with JAWS Inspect
Ready to learn how screen reader users are experiencing your website? Schedule a demo now.
CSUN General Call for Presentations
Opens on September 4 and concludes September 23. The 41st conference will be held March 9 through 13, 2026, at the Anaheim Marriott.
H.R.3417 – Websites and Software Applications Accessibility Act of 2025
US Congress: To establish uniform accessibility standards for websites and applications of employers, employment agencies, labor organizations, joint labor-management committees, public entities, public accommodations, testing entities, and commercial providers, and for other purposes.
Legal Update: August 2025
Converge Accessibility: Southern District of NY cases, Nexus Still Required in Third Circuit, Federal versus State Court in CA, Eighth Circuit, Bill Tracker.
OKLCH color picker, generator and converter
Jakub Krehel: Because OKLCH’s lightness ties directly to contrast, it’s easier to make color palettes that are readable and accessible.
The Accessibility Paradox
Aparajita Marathe & Anne Marie Piper: How Blind and Low Vision Employees Experience and Negotiate Accessibility in the Technology Industry
A Web Developer’s Guide to Buttons vs Links
A11y Collective: Get clear guidance on proper usage, accessibility requirements, and UX best practices for your web development projects.
The web behind glass
Medienbäcker Thomas Günther: advice for designing and developing websites for the delightful and elegant new design language, Liquid Glass.
The Lifespan Gap
Grace Dow: Adults with intellectual and developmental disabilities are dying nearly 20 years earlier than the general population.