You're building a form. Three fields, a date picker, a submit button. It looks fine in the simulator, and it ships. Two weeks later, a support ticket arrives: "I can't select the date. VoiceOver just reads 'button, button, button.'" Someone on your team spends two hours with a screen reader before realising the picker has no accessible label on the trigger, and the modal never traps focus. The fix takes eight minutes. The delay took fourteen days.
That gap—between mobile accessibility guidelines printed on a WCAG page and the twenty lines of code that actually make your app usable—is where most teams lose hours. What follows is what I wish someone had handed me on day one: the platform-level rules that matter, the code that implements them, and the testing routine that catches what automation misses.
Key takeaways
- WCAG 2.2 level AA is the baseline; there is no separate W3C "mobile" document, so you apply the same success criteria to native screens.
- Touch targets need a minimum of 24×24 CSS pixels (WCAG 2.5.8), but 44×44 points / 48×48 dp is the platform expectation and what users' thumbs actually need.
- Every interactive element needs a name, a role, and a state. On Android that's
contentDescriptionplus semantics; on iOS it'saccessibilityLabelplusaccessibilityTraits. - Automated scans catch perhaps a third of real problems—the rest requires TalkBack and VoiceOver switched on.
- Do not disable system accessibility settings (large text, reduced motion) to preserve your layout. Adapt instead.
- Accessibility work shortens test cycles: accessible labels double as UI test selectors.
What mobile accessibility guidelines actually require of you
Let's clear up a common confusion first. People search for "Google accessibility guidelines" or "Apple accessibility guidelines" expecting a checklist, and find documentation instead. The normative standard is still WCAG 2.2, and it does not care whether you ship a website or a native app—it describes outcomes. Your job is to translate those outcomes into platform APIs.
The four principles, translated into practice
WCAG's foundation is POUR: perceivable, operable, understandable, robust. On mobile, each one collapses into something concrete:
- Perceivable — contrast ratios, text scaling, and alt text for informative images. A chart with no text alternative is invisible to a blind user.
- Operable — the whole interface reachable by switch control or a keyboard, not just by tapping.
- Understandable — consistent labels, error messages that say what to do next rather than what went wrong.
- Robust — correct semantic roles so assistive tech can interpret your custom components.
The criterion that trips up mobile teams most often is 1.3.4 Orientation: your app must work in both portrait and landscape unless a specific orientation is genuinely essential. I've seen a banking app lock to portrait for no better reason than "the design looked better." That's a failure, and it penalises users with devices mounted on wheelchairs or bed frames.
The mobile-specific criteria most articles forget
Four success criteria were added or strengthened specifically because of touch interfaces, and they're the ones I check first in an audit:
- 2.5.1 Pointer gestures — if your app requires a swipe or a pinch, provide a single-pointer alternative. A custom slider that only responds to drag is unusable for someone with tremors.
- 2.5.2 Pointer cancellation — actions should fire on release, not on press, so a user can slide their finger away to cancel.
- 2.5.4 Motion actuation — shaking or tilting the device must never be the only way to trigger something.
- 1.3.4 Orientation — covered above, and still ignored.
Here's the thing about 2.5.2 that took me an embarrassing amount of time to internalise: it applies to everything, including your custom segmented control that fires an API call the moment a segment is touched. Move that call to the release handler.
Touch targets, contrast, and the numbers that matter
Numbers are the easy part of this work, which is why they're the part everyone quotes and the part that gets implemented wrong. Let's be precise.
| Criterion | Requirement | Practical target | Why |
|---|---|---|---|
| Touch target size (2.5.8, AA) | 24×24 CSS px minimum | 44×44 pt (iOS), 48×48 dp (Android) | The WCAG floor is a floor; platform guidance reflects real thumb accuracy |
| Text contrast (1.4.3, AA) | 4.5:1 normal, 3:1 large | 4.5:1 everywhere, 7:1 for body text if you can | Sunlight and low-quality panels eat contrast fast |
| Non-text contrast (1.4.11) | 3:1 for UI components and graphics | 3:1 for input borders, icons, toggle states | Disabled and unchecked states are the usual casualties |
| Spacing exception | Targets can be smaller if 24px of clear space surrounds them | Avoid relying on it | The exception is legal, not kind |
Contrast is where designers and developers argue. My position: never ship grey-on-grey placeholder text below 4.5:1. It looks refined in Figma and vanishes on a phone held at an angle. Test contrast on the actual device, outside, once. You'll stop debating.
Why your toggle switch is probably failing
Non-text contrast is the criterion nobody checks. A switch's off-state track at #E0E0E0 on a #FFFFFF card is roughly 1.3:1—invisible to anyone with reduced contrast sensitivity. Same for your input field borders, your checkbox ticks, and the little chevrons in your list rows.
The fix is mechanical: darken the component token until it clears 3:1 against its background, in both light and dark themes. I keep a comment in our design tokens file next to every border colour, with the measured ratio. It has saved more regressions than any code review.
Android accessibility guidelines: the APIs that count
Android gives you the semantics for free if you use the right widgets. Where teams break things is custom views—a Canvas-drawn chart, a bespoke rating bar, anything composed from rectangles.
Labels, roles, and the contentDescription trap
Every meaningful element needs a spoken name. Compose and Views solve this differently, but the principle is identical.
In Jetpack Compose, images take a contentDescription; pass null for purely decorative ones. Interactive elements get Modifier.semantics with a role—Role.Button, Role.Checkbox—and a state description for toggles. Clickable modifiers already announce click actions, so don't bolt on redundant text.
In the older View system, ViewCompat.setAccessibilityDelegate lets you override onPopulateAccessibilityEvent for custom composites; importantForAccessibility decides whether a node is exposed or merely acts as a grouping container. Set it to YES for the row that matters and to NO for the eleven text views inside it, then give the row one coherent description.
The trap: a custom view drawn in onDraw that never creates child nodes. TalkBack doesn't see anything to focus. You need virtual view nodes, and they are fiddly to maintain correctly—which is why I'd rather rebuild the chart as a list of accessible rows than implement the virtual tree. Boring wins.
The Accessibility Scanner workflow
Android's Accessibility Scanner runs on-device and flags contrast, small targets, missing labels, and unlabelled images. It's a free app, and it takes about ten minutes per screen. I run it before every release on the five screens with the most traffic. Roughly a third of what it reports is legitimate; the rest is false positives from decorative overlays. That noise ratio is fine—it's still the cheapest first pass available.
iOS, Flutter, and React Native: where semantics slip
Cross-platform frameworks are the quiet killer here. A React Native View with an onPress is not a button to a screen reader—it's a plain container. Flutter's GestureDetector behaves the same way.
The three attributes every iOS control needs
On iOS, a custom control must expose three things: an accessibilityLabel (what it is), an accessibilityTraits value (what it does—button, selected, adjustable), and a accessibilityValue for anything with state, like a slider at 60%. Miss the trait and VoiceOver says "text" where it should say "button," and users won't know to double-tap.
In Flutter, wrap with Semantics(label: ...) and mark decorative children excludeSemantics: true. In React Native, use accessibilityRole="button", accessibilityLabel, accessibilityState, and set accessible={true} on the wrapper so children merge into a single focusable node.
A mistake I made with a toggle group
I once shipped a filter row of five toggle chips, each a React Native TouchableOpacity with a label. VoiceOver read all five labels individually, which seemed correct. It wasn't: the selected state was conveyed purely by border colour, so a blind user heard "Running, Filter, Running, Filter" with no idea which chips were active. Adding accessibilityState={{selected: isActive}} took four lines. The fix went out a week before someone complained. I got lucky.
Mobile app accessibility testing beyond the scanner
Automated checks are necessary and profoundly insufficient. What they cannot catch: an illogical focus order, a form that reads "date" instead of "departure date," a modal that lets focus escape to the content behind it, or an error message that appears visually while the screen reader stays silent.
A testing routine you can do in fifteen minutes
- Turn TalkBack or VoiceOver on and complete your primary task using only the screen reader—no looking at the screen.
- Turn on large text (200%) and check nothing clips or overlaps. I use Adaptive text in iOS settings and font scale 2.0 in Android's developer options.
- Enable your platform's colour correction or dark mode and re-check contrast on tints and disabled states.
- Switch on Reduce Motion and confirm animations degrade gracefully rather than freezing state transitions.
- Disconnect your mouse and run the whole flow with a hardware keyboard.
Fifteen minutes. That's the entire cost of catching the failures that generate the majority of your accessibility bug reports. The first time I did it, I found six issues in one screen. The second time, two. It compounds.
Which leads to the point most articles skip: do not disable system accessibility settings to protect your layout. If your app requests that users turn off large text or bold text because the design breaks, that's a failure of your layout, not of their preference. Use flexible containers, avoid fixed heights on text rows, and let labels wrap.
Frequently asked questions
What should go in a mobile app accessibility checklist?
Keep it to what you'll actually run: every interactive element has a spoken name and role; contrast passes 4.5:1 and 3:1 for components; touch targets meet 44×44 pt or 48×48 dp; focus order follows the visual order; no information is conveyed by colour alone; the whole flow completes with a screen reader; and text survives 200% scaling. Anything longer doesn't get used before a release.
Are Google and Apple accessibility guidelines the same?
The outcomes align, the vocabulary doesn't. Both map back to WCAG, but Android speaks in terms of semantics, content descriptions, and accessibility services, while iOS speaks in labels, traits, and values. Write your internal checklist in WCAG language so it survives platform churn, then implement it twice with each platform's own APIs.
Which testing tools are worth installing?
Accessibility Scanner on Android, the Accessibility Inspector in Xcode, and an automated scan in CI (axe on hybrid screens). Then TalkBack and VoiceOver, which are not tools in the same sense but are where the real findings come from. I've never once shipped a feature where the scanner alone found the problems that mattered.
The eight-minute fix at the top of this article isn't the interesting part. The interesting part is that the developer who wrote that picker wasn't careless—they'd never been told that a custom component has to announce its own role. Guidelines don't get applied because someone memorised a document. They get applied when the person writing the component knows what to check, and when turning on a screen reader costs fifteen minutes instead of a planning meeting. Next time you open a pull request with a custom control, run the screen reader over it before you merge. You'll probably find something. Everyone does, the first few times.