Topic domain
Accessibility
Interfaces that work for people with diverse abilities.
- Articles
- 80
- Clusters
- 8
- Foundational
- 24
- Intermediate
- 32
- Advanced
- 24
Screen readers, switches, and input methods.
- The Screen Reader Announcement Pipeline
- Accessible Name Computation
- Switch Access and Row-Column Scanning
- Braille Displays and the Translation Layer
- Text-to-Speech Synthesis Under the Hood
- Live Regions and Asynchronous Announcements
Roles, names, and computed structure.
- How a Document Becomes an Accessibility Tree
- The Order of Sources in Accessible Name Computation
- Implicit Roles and How Role Conflicts Resolve
- Mapping ARIA Roles onto Platform Accessibility APIs
- Static Text Objects and the Text Interface
- Hidden Subtrees and Presentational Roles
Navigation order and focus management.
- How the Browser Computes the Tab Sequence
- Which Elements Can Actually Take Focus
- Focus Rings, :focus-visible, and the Heuristic Behind Them
- Containing Focus Inside a Modal Surface
- Roving tabindex and Active Descendant Compared
- Restoring Focus After the Focused Element Disappears
Perception
10Contrast, motion, and sensory alternatives.
- Computing Relative Luminance and Contrast Ratios from sRGB Values
- Which Boundary Counts for Non-Text Contrast and Focus Indicators
- Redundant Encoding: When Color Cannot Be the Only Signal
- Measuring Contrast When Text Sits on a Photograph
- Perceptual Contrast Models and Why Weight and Polarity Change the Verdict
- Forced Colors Mode and the System Color Keywords
Labels, validation, and recovery.
- Label Association and the Accessible Name of a Form Control
- Fieldset and Legend Group Semantics
- Autofill Tokens and the Purpose of an Input
- Placeholders as a Fallback Name and Why They Fail
- Native Constraint Validation and the ValidityState Object
- Wiring Error Messages to Their Fields
Custom widgets and live regions.
- The Role Attribute as a Contract With the Accessibility Tree
- Mirroring Widget State Into ARIA Attributes Without Drift
- How Live Regions Turn DOM Mutations Into Speech
- Roving tabindex and aria-activedescendant as Competing Models
- Hiding Subtrees Without Breaking Focus or the Tree
- The Combobox Popup Contract: Ownership, Focus, and Announcement
Automated checks and manual verification.
- What an Automated Accessibility Check Can Decide
- The Accessibility Tree as a Test Oracle
- How an Accessibility Rule Engine Decides
- Why Zero Violations Is Not a Pass
- A Sequential Focus Test Protocol
- Measuring Contrast From Rendered Pixels
Constraints as design input.
- Designing for the Tails of an Ability Distribution, Not the Mean
- Permanent, Temporary, and Situational Constraints as a Single Design Axis
- The Curb-Cut Effect and the Marginal Cost of Building a Constraint In
- Fitts Law as a Target-Size Constraint: Throughput, Index of Difficulty, and Hit Area
- Error Tolerance and Recovery as a Layout Requirement
- Linearization: Why Visual Reordering Breaks Reading and Focus Order
All Accessibility articles
- Oct 6, 2026 Mapping ARIA Roles onto Platform Accessibility APIs How a role token becomes an MSAA role, an AXRole, or an AT-SPI role, which properties carry states, and where the mappings diverge.
- Sep 30, 2026 Virtual Cursors and Browse Mode How a screen reader maintains a separate reading cursor over a virtual buffer of the page, distinct from real keyboard focus, and why the two desynchronize.
- Sep 24, 2026 Focus Across Shadow Roots and Frame Boundaries Where document.activeElement points when focus enters a shadow tree or an embedded document, what delegatesFocus changes, and why a custom element that contains a field is not a tab stop by default.
- Sep 23, 2026 How prefers-reduced-motion Reaches an Animation and What It Cannot Stop The media query reports a user setting, so authors must honour it in CSS and in script; which motion triggers vestibular symptoms, and why duration is the wrong knob to turn.
- Sep 11, 2026 Why Zero Violations Is Not a Pass Automated checks cover a minority of success criteria, report a large incomplete queue, and cannot observe interaction, so a clean run bounds failure rather than proving conformance.
- Sep 9, 2026 The Role Attribute as a Contract With the Accessibility Tree How a role token rewrites what the accessibility tree exposes, why it adds no behaviour, and how the first valid token in a list wins.
- Aug 24, 2026 A Sequential Focus Test Protocol How to record and verify tab order, focus visibility, and focus containment, and what tabindex values, inert subtrees, and dialogs do to the sequence.
- Aug 17, 2026 Roving tabindex and aria-activedescendant as Competing Models Two ways to keep one tab stop inside a composite widget: moving real DOM focus between items, or holding focus on a container and pointing at an item. Their costs differ in event routing, virtualisation, and IME handling.
- Aug 1, 2026 Accessible Name Computation How a screen reader derives the single name string for an element from text, labels, aria-labelledby, and fallbacks, and why precedence rules matter.
- Jul 30, 2026 Keeping Focus Stable in Virtualized and Reordered Lists Why windowing libraries lose focus when they recycle nodes, how sorting a list breaks a tab stop, and what content-visibility does to the focusability of skipped subtrees.
- Jul 21, 2026 Hiding Subtrees Without Breaking Focus or the Tree display none, visibility hidden, aria-hidden, and the hidden attribute remove content from different layers. Choosing wrong leaves focusable nodes inside invisible subtrees or visible text absent from the tree.
- Jul 9, 2026 Braille Displays and the Translation Layer How a refreshable braille display turns screen text into dot patterns through character encoding, and why contracted braille requires a separate translation step.
- Jul 8, 2026 Error Summaries and Focus Placement on Failed Submission Where focus goes when a form rejects a submission, why a summary block beats a browser bubble, and how to make the summary navigable.
- Jul 4, 2026 Custom Widgets Over Virtualized Content When only the visible window of a list exists in the DOM, the accessibility tree holds a fragment of the data. Position, size, and the active item have to be reported through attributes rather than structure.
- Jul 3, 2026 The Combobox Popup Contract: Ownership, Focus, and Announcement What a text input and its suggestion list must agree on to be one widget: the popup relationship, where DOM focus lives during typing, and who announces the active option.
- Jul 2, 2026 The Screen Reader Announcement Pipeline How a screen reader turns an accessibility-tree event into spoken output, from event dispatch through speech synthesis, and where latency and interruption come from.
- Jun 29, 2026 Working Memory Limits as a Constraint on Form Structure How chunking, recognition over recall, and progressive disclosure keep the number of simultaneously held items inside a plausible working memory budget, and where the chunking argument is misapplied.
- Jun 19, 2026 Conformance Evidence and Defect Triage How to assemble a defensible accessibility claim: sampling by template, recording scope and exceptions, ranking defects by user impact, and keeping the evidence current.
- Jun 16, 2026 Fitts Law as a Target-Size Constraint: Throughput, Index of Difficulty, and Hit Area How the time to acquire a target scales with distance and width, why width beats distance in interface layout, and what the model does not predict about real pointing.
- Apr 30, 2026 Verifying What a Screen Reader Actually Says How speech output is produced from accessibility events, why announcement assertions are brittle across reader versions, and which properties can be tested stably.
- Apr 24, 2026 Restoring Focus After the Focused Element Disappears When a focused node is removed the browser falls back to the body, and the next Tab press restarts at the top of the page. How to choose a restoration target from structure rather than from memory.
- Apr 21, 2026 Live Regions and Asynchronous Announcements How aria-live regions cause screen readers to announce content that changes without focus moving, and how the polite and assertive politeness levels are implemented.
- Apr 16, 2026 Forced Colors Mode and the System Color Keywords How forced colors replaces author colors with a user-chosen palette, which properties survive, and the design habits that break when backgrounds are overridden but borders are not.
- Apr 3, 2026 Implicit Live Values in status, alert, log, and timer Roles Live roles carry default politeness and atomicity from their definitions, so the role chooses behaviour the author never wrote. Where those defaults help, and where overriding them produces a contradictory tree.
- Mar 28, 2026 Linearization: Why Visual Reordering Breaks Reading and Focus Order How DOM order determines both the reading order for assistive technology and the focus sequence, why CSS ordering properties desynchronize them from the visual layout, and how to keep the four orders aligned.
- Mar 15, 2026 Which Elements Can Actually Take Focus The closed list of natively focusable elements, the three independent exclusions that remove an element from that list, and why a call to focus() can return without moving focus at all.
- Mar 14, 2026 Focus Order and the Accessibility Tree How tabindex, DOM order, and the tree order diverge, and why the tab sequence and the reading order are computed from different structures.
- Mar 8, 2026 Roving tabindex and Active Descendant Compared Two ways to give a composite widget one tab stop: moving tabindex among items, or keeping focus on a container and pointing at an item with aria-activedescendant.
- Feb 17, 2026 Designing for the Tails of an Ability Distribution, Not the Mean Why a design calibrated to an average body or an average user excludes most people, and how percentile bands and requirement envelopes replace the average as a design input.
- Jan 26, 2026 Container Roles and Nested Structure How group, region, and composite containers nest, what nesting does to landmark and heading navigation, and when a wrapper should carry a role at all.
- Jan 7, 2026 Word Prediction and Accelerated Text Entry How word prediction and abbreviation expansion reduce the keystroke cost of text entry for switch and scanning users, and how the prediction model trades accuracy for input rate.
- Jan 2, 2026 Which Boundary Counts for Non-Text Contrast and Focus Indicators How the 3:1 requirement applies to component edges, icons, and focus rings, why the measured pair is the two colors on either side of a boundary, and how state changes are evaluated separately.
- Dec 26, 2025 Eye Tracking and Gaze-Based Selection How an eye tracker estimates where a user is looking, why gaze alone is a poor pointer, and how dwell and other schemes turn gaze into reliable selection.
- Dec 24, 2025 Inline Validation Timing and When Errors Should Speak How validation on blur, on input, and on submit differ in what they interrupt, how debouncing and politeness control announcement, and why premature feedback degrades entry.
- Dec 22, 2025 What an Automated Accessibility Check Can Decide Which accessibility questions resolve from the serialized DOM and computed style, which require judging meaning, and why an engine cannot tell the difference on its own.
- Nov 27, 2025 Skip Links and the Sequential Navigation Starting Point Why a bypass link works even though it usually points at a non-focusable heading, how the browser positions the tab sequence at the fragment target, and what single-page routing breaks.
- Nov 17, 2025 How an Accessibility Rule Engine Decides The parse, match, evaluate, and report stages inside a checker like axe-core, how rule results are graded, and why the same page yields different reports from different tools.
- Oct 7, 2025 How the Browser Computes the Tab Sequence The tree walk behind the Tab key: tabindex partitioning, the sequential focus navigation starting point, and why a positive tabindex can send focus backwards through the page.
- Sep 1, 2025 Autofill Tokens and the Purpose of an Input How the autocomplete attribute encodes what a field means, how browsers and assistive technology consume it, and why the token set is a closed vocabulary.
- Aug 19, 2025 Preventing Irreversible Errors in Consequential Submissions How confirmation, review, and reversal mechanisms trade friction against irreversibility, and where each mechanism fails for users who cannot see the mistake.
- Jul 18, 2025 Computing the Flash Threshold: Luminance Steps, Area, and the Red Flash Rule Photosensitive seizures depend on the size, luminance delta, and frequency of a flashing region; how the general and red flash thresholds are defined, and why a small bright animation is a different risk from a full-screen one.
- May 26, 2025 Placeholders as a Fallback Name and Why They Fail How the placeholder attribute enters the accessible name computation, why it ranks last, and the concrete failures that follow from using it as a label.
- May 14, 2025 Error Tolerance and Recovery as a Layout Requirement Why reversible actions, confirmations that name their consequence, and recovery paths must be designed as structure rather than added as dialogs, and how undo stacks and draft persistence change the cost of a mistake.
- Apr 7, 2025 How Live Regions Turn DOM Mutations Into Speech Live regions do not announce anything themselves; they mark a subtree as interesting so that mutations inside it are queued, and politeness, atomicity, and relevance decide what is spoken.
- Mar 14, 2025 Label Association and the Accessible Name of a Form Control How the for attribute and implicit nesting bind a label to a control, how that binding becomes an accessible name, and what an unassociated label leaves behind.
- Feb 27, 2025 Testing Reflow, Zoom, and Text Spacing How the reflow, resize-text, and text-spacing criteria turn layout questions into arithmetic on viewport width, scroll extents, and computed font metrics.
- Dec 6, 2024 Permanent, Temporary, and Situational Constraints as a Single Design Axis How the same underlying limitation appears as a permanent impairment, a temporary injury, or a situational condition, and why grouping requirements by function rather than by cause avoids duplicated and conflicting solutions.
- Oct 2, 2024 Measuring Contrast From Rendered Pixels Why the contrast ratio is simple arithmetic but the colour inputs are not, how effective backgrounds are composited, and what sampling rendered pixels can and cannot settle.
- Sep 27, 2024 Fieldset and Legend Group Semantics How fieldset and legend give a set of controls one shared name, how the browser exposes that grouping, and where the element falls short of what a group needs.
- Sep 18, 2024 Modal Inertness: What a Dialog Must Remove From the Rest of the Page A dialog is modal only if the rest of the document is unreachable by keyboard, pointer, and the accessibility tree. The containment mechanics, and the focus restoration that fails when the trigger is gone.
- Sep 15, 2024 Perceptual Contrast Models and Why Weight and Polarity Change the Verdict WCAG 2 contrast is a ratio between two colors; newer models predict lightness difference from a background and scale it by text size and weight, which makes polarity and stroke thickness part of the result.
- Aug 23, 2024 Checking Contrast Against What Renders, Not What Is Declared Computed styles, compositing, canvas readback, and the sampling decisions that decide whether a measured ratio corresponds to anything a reader sees.
- Aug 18, 2024 Switch Access and Row-Column Scanning How a single switch lets a user navigate every control on screen through timed scanning, and how the scan timing and group layout determine entry speed.
- Jul 11, 2024 How a Document Becomes an Accessibility Tree Which DOM nodes a browser exposes to assistive technology, which it discards, and why ignored containers are flattened instead of deleted.
- Jul 10, 2024 Focus Rings, :focus-visible, and the Heuristic Behind Them Why browsers began suppressing focus indicators on mouse clicks, how the :focus-visible heuristic decides, and what a custom indicator must do to survive forced-colors mode and clipping.
- Jul 4, 2024 Wiring Error Messages to Their Fields How aria-describedby, aria-invalid, and aria-errormessage bind a message to a control, and how the accessibility tree orders what the user hears.
- Jun 25, 2024 Native Constraint Validation and the ValidityState Object How the browser evaluates required, pattern, min, and max attributes, what each ValidityState flag means, and where the built-in validation loop breaks down.
- Jun 19, 2024 The Accessibility Tree as a Test Oracle How browsers expose roles, names, states, and relations through the accessibility API, and how tests can assert on that projection instead of on markup.
- Apr 28, 2024 Mirroring Widget State Into ARIA Attributes Without Drift Why every interactive custom widget keeps state in two places, which attributes the tree actually reads, and how a render boundary prevents the two copies from disagreeing.
- Apr 15, 2024 Static Text Objects and the Text Interface Why paragraphs become single text objects, how character offsets and range queries work, and what happens when a text run is split by inline structure.
- Mar 8, 2024 Live Regions Under Re-Rendering: Why Framework Updates Announce Nothing A live region depends on text mutations inside a stable node. Diffing renderers replace nodes, batch writes, and mount regions on demand, which silences announcements in ways that look random.
- Mar 7, 2024 Measuring Contrast When Text Sits on a Photograph A single foreground color over an image has a contrast ratio for every backdrop pixel; how to find the worst case, and what scrims, blur, and backdrop filters do to that distribution.
- Feb 21, 2024 Reflow Under Magnification: What a Layout Must Give Up at 320 CSS Pixels How text scaling and page zoom change the effective viewport, which layout techniques fail first under magnification, and the constraints that keep content usable when the viewport shrinks to a narrow column.
- Jan 30, 2024 Required Owned Elements and Structural Constraints Which roles require children, which require a parent, how engines repair an orphaned widget, and why the repair changes reading order.
- Jan 15, 2024 Redundant Encoding: When Color Cannot Be the Only Signal Why hue collapses under monochrome rendering and common color vision deficiencies, and the concrete channels — shape, position, texture, text — that carry the same information in parallel.
- Dec 15, 2023 Hidden Subtrees and Presentational Roles The difference between aria-hidden, display none, visibility hidden, and role presentation, and which of them removes a node from the tab order.
- Oct 27, 2023 The Curb-Cut Effect and the Marginal Cost of Building a Constraint In Why constraints that are cheap at design time are expensive as retrofits, how the benefit of a widened constraint spreads beyond its original justification, and where the reuse argument stops being true.
- Oct 19, 2023 The Order of Sources in Accessible Name Computation How an accessible name is assembled from aria-labelledby, aria-label, host-language labels, and content, and where the recursion stops.
- Oct 17, 2023 Computing Relative Luminance and Contrast Ratios from sRGB Values The linearisation step, the weighted sum behind relative luminance, and why the WCAG ratio adds a constant to both values before dividing them.
- Oct 6, 2023 Multi-Step Form State and What Survives a Step What a wizard loses between steps when each step is a fresh document, how a step boundary changes validation, and how to make back navigation non-destructive.
- Aug 26, 2023 The Order of Focus and Blur Events Focus moves in a fixed sequence of four events, only two of which bubble. How relatedTarget identifies the other end of the move, and why calling focus() from inside a blur handler behaves unexpectedly.
- Aug 16, 2023 Text-to-Speech Synthesis Under the Hood How a speech engine turns an SSML document into audio through text normalization, phoneme conversion, and prosody, and where screen-reader latency comes from.
- Jul 20, 2023 Contract Tests for Stateful ARIA Widgets A role-specific contract of states, key bindings, and announcements that can be asserted mechanically, and where the ARIA authoring practices stop being testable.
- Feb 27, 2023 Accessibility Tree Invalidation and Event Coalescing How engines detect that the tree is stale, what work happens before platform events fire, and why a burst of mutations can produce a single announcement.
- Jan 9, 2023 Containing Focus Inside a Modal Surface How the dialog element traps Tab natively, what a hand-rolled focus trap has to reimplement, and why returning focus to the opener is part of the containment contract.
- Dec 8, 2022 When Inclusive Constraints Conflict: Partial Orders and Documented Exceptions How to resolve collisions between accessibility constraints using a stated priority order, why an unordered checklist produces inconsistent decisions, and how to record exceptions so they stay auditable.
- Sep 12, 2022 Implicit Roles and How Role Conflicts Resolve How browsers derive a role from element and attributes, what happens when an explicit role token disagrees with the host language, and why some overrides are rejected.
- Sep 1, 2022 Encoding Accessibility Constraints in a Design System Token Layer Why constraints enforced by review decay while constraints encoded in tokens and components persist, which properties belong in the token layer, and what the approach cannot express.
- Mar 11, 2022 Cue Timing in Captions and the Problem of Describing What Is Not Said How WebVTT cues are placed in time and space, what reading-rate limits imply about line length, and why audio description has to fit into gaps that the mix does not leave.
- Nov 7, 2021 Debounce, Dwell, and Key-Repeat Filtering How assistive input systems distinguish a deliberate activation from switch bounce, tremor, and held keys, and how dwell and repeat timing are computed.