How to Integrate Accessibility into Your Design Process Using Recognition Heuristics

Introduction

Accessibility is often seen as a checklist—a long list of rules to follow. But the real challenge for designers isn't a lack of goodwill; it's the overwhelming amount of information to remember. This guide turns that problem on its head. Instead of forcing you to memorize every guideline, we’ll show you how to make accessibility issues recognizable during the design phase itself. By borrowing from Jakob Nielsen’s usability heuristic “Recognition rather than Recall,” you can create websites that work for everyone without burning out your brain. Let’s get started.

What You Need

• Basic knowledge of web design (wireframes, visual design, interaction design)
• A willingness to question your own work
• Access to Nielsen’s 10 Usability Heuristics (free online)
• A copy of A Web for Everyone by Sarah Horton and Whitney Quesenbery (recommended but not required)
• Empathy and patience

Step-by-Step Guide

Step 1: Acknowledge the Gap Between Intent and Outcome

Start by accepting a simple truth: designers are good people. No one sets out to exclude users. Yet many websites and apps remain inaccessible. Recognizing this gap—between good intentions and poor results—is your first step. Ask yourself: “Have I ever missed a contrast ratio, forgot alt text, or assumed everyone can see a color-coded status?” The answer is probably yes. That’s okay. The goal isn’t blame; it’s awareness.

Step 2: Understand That Accessibility Is Life-or-Death

Some may think accessibility is a “nice to have.” But as Aral Balkan argues in his essay This Is All There Is, nearly everything we design can affect life events or death events. A poorly designed bus timetable app might cause someone to miss their daughter’s fifth birthday—or the chance to say goodbye to a dying grandmother. Let that sink in. When you design, imagine the real human behind the screen. This emotional connection makes accessibility non-negotiable.

Step 3: Identify the Root Cause—Too Much to Recall

Why do good designers produce bad websites? The answer is cognitive overload. Designers are expected to remember an endless list of principles: visual hierarchy, typography, color theory, user flow, responsive breakpoints, and, oh yes, accessibility guidelines (WCAG, ARIA, contrast ratios, screen reader semantics). It’s too much. The brain can’t hold all that information at once. So instead of trying to remember everything, we need a system that surfaces the right information at the right time.

Step 4: Apply “Recognition Rather Than Recall” for Designers

Jakob Nielsen’s 10 Usability Heuristics date back to the mid-1990s, but they remain timeless. Heuristic №6, “Recognition rather than Recall,” originally applied to users: make options visible so users don’t have to remember. We can flip this for designers. Make accessibility requirements visible during the design process rather than storing them in a manual. For example:

• Use color contrast checkers in your design tool that highlight failing combinations automatically.
• Create annotated wireframe templates that include accessibility notes (e.g., “this button must have a label for screen readers”).
• Set up design system components that enforce accessible defaults (e.g., a button with a minimum 3:1 contrast ratio built in).

When the information is visible in your environment, you don’t have to remember it. Your tools do the remembering for you.

Step 5: Use Proven Resources to Build Recognition

One excellent resource is A Web for Everyone by Sarah Horton and Whitney Quesenbery. It provides actionable personas, scenarios, and checklists that you can embed into your workflow. Don’t just read it—place it next to your monitor. Highlight key passages. Create a one-page cheat sheet. The goal is to turn the book’s insights into visual cues that trigger accessibility thinking every time you open a design file. Similarly, bookmark WCAG quick reference and keep it open in a browser tab.

Step 6: Practice Design-Focused Accessibility Reviews

Set aside 15 minutes per design session to run a “recognition check.” Look at your current screen and ask:

• Would someone with limited vision still understand the content? (Check font size, contrast, alt text placeholders.)
• Would someone who cannot hear hear audio cues? (Are captions or transcripts needed?)
• Would someone with cognitive disabilities stay oriented? (Is navigation consistent?)
• Would someone with motor impairments use all features? (Are click targets large enough?)

This isn’t a complete audit, but it trains your brain to recognize potential issues. Over time, it becomes second nature.

Tips for Long-Term Success

• Start small. Don’t try to fix every accessibility issue at once. Pick one heuristic (like contrast) and master it.
• Create a “cheat sheet” that lists the most common design failures (low contrast, missing alt text, tiny touch targets) and pin it on your wall. Refer to Step 4 for the reasoning behind this.
• Involve users with disabilities in your testing. Nothing beats real feedback. Use their insights to refine your recognition cues.
• Celebrate small wins. Each time you catch an accessibility issue before it ships, you’ve made the web better for someone. That matters.
• Keep learning. Accessibility evolves. Follow blogs like A List Apart, read A Web for Everyone (referenced in Step 5), and experiment.

Remember: you are a good designer. Your designs can be good for everyone—if you make accessibility visible. Use the power of recognition to bridge the gap between intention and inclusion.