Zero Day Exploit

Introduction

Every designer I know is a genuinely good person. None of them would ever say, “I don’t care if someone can’t read this,” or “It’s not my problem if this interface confuses people.” Yet, despite the best intentions, many websites and apps still exclude users. The reason isn’t malice—it’s cognitive overload. Designers are expected to remember countless guidelines, from typography to interaction design, plus a growing mountain of accessibility requirements. It’s simply too much. The solution isn’t to memorize more; it’s to make accessibility issues recognizable during the design process. This guide will show you how to apply Jakob Nielsen’s heuristic “Recognition rather than Recall” to your own workflow, turning inclusive design from a mental checklist into an intuitive habit.

What You Need

• A basic understanding of web design principles.
• Access to Jakob Nielsen’s 10 Usability Heuristics for UI Design (especially heuristic #6).
• (Optional) A copy of A Web for Everyone by Sarah Horton and Whitney Quesenbery for deeper context.
• A willingness to shift your mindset from “recalling rules” to “recognizing patterns.”
• A simple checklist template (digital or paper) to log common accessibility pitfalls.

Steps

Step 1: Acknowledge the Gap Between Intention and Outcome

Start by admitting that good designers can still create exclusionary designs. You’ve seen it: text so faint it’s unreadable, buttons too small to tap, navigation that baffles new users. These aren’t signs of incompetence—they’re signs of a design process that doesn’t surface problems early. Write down a recent example from your own work where an accessibility issue slipped through. This honesty sets the foundation for change.

Step 2: Understand the Real Stakes of Accessibility

Aral Balkan, in his essay “This Is All There Is,” argues that nearly everything we design affects life events and death events. A bus timetable app might seem trivial, but a badly designed one can cause someone to miss their daughter’s birthday—or the chance to say goodbye to a dying grandmother. When you recognize that every exclusion has consequences, the motivation to act becomes personal. Keep this example in mind as you proceed.

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

Designers are inundated with information: typography rules, color theory, interaction patterns, SEO, performance—and yes, accessibility. The brain can only hold about seven items in working memory at once. Trying to recall all accessibility guidelines while juggling other constraints is unrealistic. The problem isn’t your ability; it’s the demand. The solution is to move from recall to recognition.

Step 4: Adopt “Recognition Rather than Recall” for Designers

Jakob Nielsen’s sixth usability heuristic states that users should not have to remember information; it should be visible or easily retrievable. Let’s flip that for creators: the information needed to design accessibly should be visible or easily retrievable during the design process. Create a visual anchor—a small card, a sticky note, or a browser bookmark—that lists the most common accessibility red flags. Place it where you’ll see it while designing. For example, “Contrast ratio below 4.5:1” or “Missing alt text” should jump out at you, not hide in a document.

Step 5: Build Your Own Recognition Checklist

Now turn that anchor into a practical checklist. Include issues that are easy to spot once you know what to look for:

• Text that uses only color to convey meaning.
• Images without alternative text.
• Interactive elements that rely on hover-only states.
• Font sizes below 16px for body text.
• Poor contrast between background and text.
• Missing labels on form fields.
• Navigation that isn’t keyboard-accessible.

Print it or pin it near your workspace. Each time you design a new component, scan the checklist. Over time, these items will become automatic recognition triggers.

Step 6: Embed Accessibility Checks into Your Workflow

Don’t wait until the final review. Integrate recognition into every stage:

• Sketching: Quickly mark potential trouble spots (e.g., low-contrast areas).
• Prototyping: Use tools that simulate color blindness or keyboard-only navigation.
• Peer reviews: Ask a colleague to look at your design with the checklist as a guide.
• User testing: Recruit participants with disabilities early; their feedback will make recognition second nature.

By making accessibility a recurring pattern in your process, you reduce the mental load.

Step 7: Continuously Update Your Recognition Library

Accessibility standards evolve, and new challenges emerge (e.g., dark mode, voice interfaces). Treat your checklist as a living document. Read resources like A Web for Everyone or follow A List Apart articles. When you learn a new technique, add it to your recognition triggers. The goal isn’t to memorize everything—it’s to make the knowledge visible when you need it.

Tips for Success

• Start small: Pick two or three checklist items to focus on for a week. Once they become automatic, add more.
• Use physical reminders: A printed card on your desk can be more powerful than a digital file you rarely open.
• Celebrate catches: When you spot a potential issue before code is written, acknowledge it—this reinforces the recognition habit.
• Remember the stakes: Revisit Step 2 often. The bus timetable story is a powerful motivator.
• Share your checklist with teammates: Teamwide recognition creates a culture of inclusion.
• Be patient with yourself: Changing from recall to recognition takes time. You won’t catch everything immediately, and that’s okay.

For more on applying these ideas, revisit Step 4 and the original heuristic. Accessibility isn’t an extra burden—it’s a design principle that becomes easier when you let your tools and environment do the remembering.