Mid-Level UX Designer Interview Preparation Guide - FAANG Standards

Direct answer

Don't remove the caveat, but respond fast with a concrete, shorter alternative rather than a flat no. Separate what's actually negotiable, wording, length, placement, from what isn't, the underlying risk the caveat describes, and say so out loud in the moment.

Structured elaboration

• Draw the line explicitly, right then: "I can't drop it entirely because it's a real constraint on what we can commit to, but I can make it tighter." That single sentence tells your colleague you're not being difficult, you're protecting something specific.
• Offer the rewrite immediately, not later. A fast, concrete alternative keeps you the collaborator in the room instead of the blocker; a flat "no, we need it" without an alternative invites exactly the pushback you're trying to avoid.
• If genuinely rushed, propose a placeholder now and a follow-up pass, rather than caving to get the slide out the door on time.
• Know when it's actually fine to cut. Ask: would removing this change what the executive decides or commits to? If the caveat is a hedge nobody will act on, trimming it is reasonable editing, not a compromise on accuracy. This case isn't that: the caveat describes a real performance limit that affects what can be promised.

Worked example

In the moment: "Thanks, I get wanting it to land cleanly for the execs. I can't remove that caveat entirely, it's a real constraint on what we can commit to, but I can reword it so it's short and exec-friendly. Want a one-line version that leads with the mitigation, or should we keep the technical detail in an appendix slide instead?"

Example transformation:

• Original (too technical): "Performance may degrade over 20% under sustained 10k concurrent writes without sharding."
• Executive-friendly (caveat preserved): "Under very high sustained write volume, throughput can drop, we mitigate this with sharding (splitting the data across multiple machines), and engineering will scope that work during the pilot."

Trade-offs & pitfalls

The failure mode in one direction is caving to a flat "just remove it" and letting a real risk disappear from the record, that's the version that comes back to bite the team when the limit gets hit in production and nobody remembers it was flagged. The failure mode in the other direction is treating every caveat as sacred and refusing to trim genuinely low-materiality hedges, which trains colleagues to see you as an obstacle rather than someone protecting the parts that matter. If your colleague pushes past a quick reword and asks you to cut something material, don't fight it out live in front of the deck, a quick "let's take five minutes offline before this goes out" resolves it without an audience.

Direct answer

Treat the time limit as a constraint on the answer itself: pick one project you can defend under open questioning, script a tight narrative arc (context, problem, key decisions, outcome) that fits the time, and spend at least as much prep time anticipating the panel's likely challenges as polishing the walkthrough itself.

How to plan it

• Pick the project by defensibility, not impressiveness: choose the one where you can answer "why," not just "what," for every major decision, because open Q&A after a timed presentation exists specifically to test that.
• Script to the clock: roughly 20% context and problem, 50% key decisions and trade-offs, 30% outcome and what you'd change, then rehearse against a timer. Cutting content is easier before the room than mid-sentence in it.
• Prepare a "resume-on-demand" structure: have 2 to 3 artifacts (a prototype, a chart, a metric snapshot) ready to pull up instantly if a question calls for evidence, rather than describing them from memory.
• Anticipate the panel's default questions: "why this approach and not an alternative" and "how do you know it worked" come up in almost every panel, have both answers ready before you start.
• The same shape holds whether the format is a live prototype walkthrough (design loops) or a 5-slide project summary (data-science loops): fixed time, one artifact, then open technical questioning.

Worked example (skeleton)

A 5-minute slot on a project where I owned a feature end-to-end. Script: 1 minute on the problem and constraint, 2.5 minutes on the two approaches I considered and why I picked one, 1.5 minutes on the result and what I'd change with more time. Result stated honestly: a usability test with 11 participants showed task completion move from 7 out of 11 to 10 out of 11 between the first and revised prototype, a count I can point to directly rather than a rounded percentage. I keep the clickable prototype and the raw test notes open in a second tab, so if the panel asks to see the failure case, I'm one click away instead of describing it verbally.

Trade-offs and pitfalls

• Over-preparing the walkthrough and under-preparing for questions is the most common failure, panels remember how you handled pushback more than how polished the script was.
• Picking the most visually impressive project instead of the one you can defend three questions deep leaves you exposed exactly when it matters most.
• Running over time because you tried to cover too much ground; a shorter, sharper story leaves more of the slot for what's actually being evaluated, live technical reasoning.

Direct answer

In the room, I'd stay visibly composed, acknowledge the specific point without over-apologizing or arguing, and ask one narrow clarifying question to turn a vague public jab into something concrete. In the 48 hours after, I'd follow up privately to fully understand the concern, do the actual rework based on what I learned, and close the loop with both the critic and the room.

Structured elaboration

In the meeting. Pause before responding rather than reacting immediately. Thank them for the specific point, even if the delivery was blunt. Ask one narrow clarifying question rather than defending the whole piece of work. Avoid both capitulating completely and getting visibly defensive; either reads as junior in a different way.

Within 48 hours. Reach out privately to the person who criticized the work to get the full, unfiltered version of the concern away from the pressure of the room, since public critique is often compressed or, sometimes, sharper than intended.

Do the actual rework. Base it on what you learned in the private follow-up, not a surface patch based on a guess.

Close the loop. Share the revised work back with the room or at least the critic, showing the specific change made in response, which repositions the public moment as the start of a fix rather than a public failure that just sat there.

Worked example

Early in a design role, I presented a checkout flow in a cross-functional review, and a senior product manager said in front of the group that the flow "clearly hadn't been thought through," pointing at the confirmation step. In the room, I paused and said "thanks, can you say more about what felt unclear in that step specifically," which got a more specific answer, users wouldn't understand what happened to a saved item if they backed out at that point, instead of leaving it as a vague public dismissal. I didn't defend the design or agree on the spot to redo the whole flow.

Within the next day, I messaged the product manager directly and asked a few more questions about the exact user scenario they had in mind. The issue was narrower than "the whole flow": one specific edge case wasn't handled in the mockup. I reworked that specific interaction, and by the end of the 48 hours sent a short follow-up to the review's channel showing the updated flow with the fixed edge case called out explicitly, putting a concrete resolution on record rather than letting the public criticism stand as the last word.

Trade-offs and pitfalls

Over-apologizing or agreeing to a full redo in the room to make the discomfort stop usually means fixing the wrong thing, since the real concern hasn't been pinned down yet. Getting visibly defensive in the moment, even if the critique was unfair or badly delivered, reads worse for a junior designer than the original critique did. And skipping the private follow-up, quietly fixing something based on a guess about what they meant, risks solving a problem they didn't actually raise.

Direct answer

Card sorting is generative: it builds a candidate structure from how people actually group and name things. Tree testing is evaluative: it checks whether people can successfully navigate a structure that already exists or has been drafted. If there is no defensible structure yet, or the existing one is failing and you do not know why, tree testing alone will only reconfirm the failure; card sorting is what tells you how to fix it.

Structured elaboration

Open versus closed card sorting

• Open sort: participants invent their own categories and labels while grouping content. Use it early, before any structure exists, to surface real mental models.
• Closed sort: participants sort content into categories you already propose. Use it once a draft structure exists, to check fit and find misplaced items.

How card sorting differs from tree testing

Recruitment and sample size, per method

• Open card sort: 15 to 30 participants, a mix of personas, since new categories tend to stabilize around that range.
• Closed card sort: 20 to 50 participants, for a more confident per-item placement read.
• Tree test: 30 to 50 participants per structure being tested, since success rate needs enough sessions per task to be more than anecdote.

Translating results into actual IA (information architecture) changes

1. From the open sort, cluster items and normalize labels (merge synonyms, keep the language participants used).
2. Draft a candidate navigation structure from that clustering.
3. Validate the draft with either a closed card sort (does the grouping still hold with a larger, more diverse group) or a tree test (can people actually find things in the resulting hierarchy).
4. Ship only the changes the validation step actually supports: a relabel where an item was simply misnamed, a structural move where an entire category was hard to find, not the full original hypothesis unmodified.

Worked example

Open sort insight that changes labeling. Participants sorting a retail site's content repeatedly group "returns policy," "warranty," and "order status" under a self-invented "Help & Orders" label, even though the current navigation splits them across "Support" and "My Account." The fix: merge them into a single "Orders & Support" section using the participant-generated label, not an internally preferred one.

Closed sort insight that changes categorization. Testing a candidate taxonomy, many participants place "Gift cards" under "Promotions" instead of the proposed "Account" category. The fix: move the item, and rename it "Gift cards & Offers" so the new location matches the label.

Tree test insight the card sort alone would have missed. After shipping the "Orders & Support" merge, a tree test on the resulting hierarchy shows a 55% success rate for the task "find out why your order was delayed," with most failures ending in the "Orders & Support" section but on the wrong sub-node. This tells the team the top-level merge was right (people go to the right section) but the sub-structure underneath still needs work, exactly the kind of navigational finding a card sort cannot surface, since a card sort never asks anyone to actually navigate anything.

Trade-offs and pitfalls

• Skipping straight to a tree test on a structure nobody validated generatively risks confirming that a guess is wrong without ever learning what would be right.
• Skipping tree testing after a card sort risks shipping a taxonomy that reads well on paper but fails once real navigation and labels compete for attention on an actual screen.

Direct answer

Reach for container queries when a component needs to respond to the space it is actually placed in (a card that looks different in a narrow sidebar versus a full-width section), viewport breakpoints when the whole page layout needs to shift together, and fluid scaling (clamp()) for smooth adjustments like type size or padding between those breakpoints. Document the rule as part of each component's spec, not as a separate, easily-forgotten page, so designers and engineers implement the same behavior without re-deriving it per component.

Structured elaboration

Techniques and when each applies

Container queries versus global media queries for a shared component

A component in a design system is reused in contexts the component itself does not control, a dashboard widget, a sidebar card, a full-width hero. A viewport media query answers "how wide is the browser window," which tells you nothing about how wide this specific instance is. A container query answers "how wide is the element I actually have to render into," which is the question a reusable component actually needs answered. For genuinely page-level decisions (does the whole app switch to a mobile nav), a viewport media query is still the right tool, since there is no meaningful "container" above the page itself.

Browser support and fallback

Container queries now have broad support across current evergreen browsers (Chrome, Firefox, Safari, Edge), so for most product surfaces no fallback is required. A fallback is only a real concern when a specific supported environment still uses an older engine (an embedded webview pinned to an old OS version, for example). In that narrow case, degrade gracefully rather than blocking the feature: feature-detect with @supports (container-type: inline-size) and fall back to a fixed, conservative layout (the narrow-container variant) rather than a broken one, or use a ResizeObserver-based JavaScript fallback only if that specific environment must be supported and container queries genuinely are not available there.

Documenting responsive behavior

Add a "Responsive behavior" section to each component's spec, alongside its props table, that states: which technique is used (breakpoint, container query, or fluid scale), the specific trigger values, which visual properties change, and a screenshot or embed at two or three representative sizes. Keeping this next to the prop documentation, rather than in a separate cross-cutting responsive-design guide, means an engineer implementing the component sees the rule at the point of use instead of needing to remember a separate reference.

Worked example

A Card component needs to look right both in a 320px sidebar and a 900px full-width section.

• container-type: inline-size is set on the Card's wrapper so the component can query its own rendered width, independent of the page's viewport width.
• Below a 420px container width, Card stacks its image above its text (narrow layout); at or above 420px, it switches to image-beside-text (wide layout). This threshold is expressed as a container query, not a viewport media query, so the same Card instance renders correctly in a 320px sidebar and would also render the wide layout correctly if that same sidebar were later widened to 500px, without any change to the surrounding page layout.
• The Card's internal padding uses clamp(12px, 4cqi, 20px) (container-query-relative units) so padding scales smoothly with the container's width instead of jumping abruptly at the 420px threshold.
• The component spec documents this as: "Stacks below 420px container width, switches to side-by-side at or above 420px; padding scales fluidly between 12px and 20px based on container width," with a screenshot at 320px, 420px, and 900px.

Trade-offs and pitfalls

• Using a viewport media query for a component-level layout decision is the most common mistake; it works by coincidence when the component happens to fill most of the viewport, and breaks silently the first time the same component is reused in a narrower context like a sidebar or a modal.
• Overusing fluid scaling for structural changes (trying to clamp() a layout from stacked to side-by-side) produces awkward in-between states; reserve fluid scaling for continuous properties like size and spacing, and use a container query or breakpoint for discrete layout switches.
• Documenting responsive rules only in a general design-system guide, separate from the component's own spec, means the rule gets missed by whoever implements or modifies that specific component later; keep the rule attached to the component it governs.
• Setting container-type on every wrapper "just in case" has a real performance cost (it constrains layout containment); apply it deliberately to the specific containers whose components actually need to query their own size.

Direct answer. Every accessible UI must support tab, enter, space, arrow keys, and escape as a baseline, plus home/end for lists and grids, because these are the keys a keyboard-only user, a switch-access user, and most screen reader users rely on for basic operation, and each has a specific, non-interchangeable role.

The keys and what they mean.

• Tab / Shift+Tab: move forward/backward between focusable elements in logical order. This is the fundamental navigation primitive; if focus order doesn't match visual/reading order, everything downstream breaks.
• Enter: activate the focused element (links, buttons, form submission).
• Space: activate buttons and toggle checkboxes; also scrolls the page when focus is on a non-interactive area, which is a common source of accidental scroll if a custom component captures Space without checking it isn't also needed for scrolling.
• Arrow keys: move within a composite widget (a menu, a set of radio buttons, a tab list, a listbox) rather than between separate focusable elements; this is the roving-focus pattern, distinct from Tab.
• Escape: close or cancel the current context (a modal, a dropdown, an in-progress edit) without committing a change.
• Home/End: jump to the first/last item in a list, grid, or composite widget.

Ensuring logical tab order and skip links. Tab order should follow DOM order, which should match visual/reading order; avoid positive tabindex values (tabindex="5") to manually reorder focus, since they create a separate, hard-to-maintain ordering that silently breaks the moment the DOM structure changes. A "skip to main content" link, visually hidden until focused, as the very first focusable element on the page, lets a keyboard user bypass repeated navigation and reach the main content in one keystroke rather than tabbing through the whole header every single page load.

Testing strategy. A manual keyboard-only pass (unplug the mouse, or simply don't use it) through every interactive flow, checking that every control is reachable, every action achievable, and that focus never gets visually lost or trapped somewhere unintentional; automated tools can partially verify tab order and the presence of a skip link but cannot verify the FULL interaction model (whether arrow keys correctly implement roving focus within a composite widget), so this remains a manual-testing-dependent area.

Trade-offs and pitfalls. Confusing when to use Tab (moving between separate controls) versus arrow keys (moving within one composite control) is the most common implementation mistake, producing widgets where every option in a menu is a separate Tab stop rather than one Tab stop with arrow-key navigation inside it, which makes a long list exhausting to navigate by keyboard.

Direct answer

Run the qualitative work first, lightweight, to sharpen a vague hunch into a specific, testable hypothesis, then run the A/B test to find out whether that change actually moves the funnel at scale. The two methods answer different questions (why people hesitate versus whether removing the hesitation measurably helps), so the plan should sequence them rather than treat them as competing sources of truth.

Structured elaboration

Qualitative methods: a handful of moderated sessions (5 to 8) watching people move through the current signup funnel, focused on where they pause, backtrack, or abandon, plus a short intercept survey at the drop-off point asking what almost stopped them. The goal here is narrow: surface and sharpen a hypothesis, not produce a full research synthesis, that discipline belongs to a deeper research effort and isn't what this plan needs to do well.

A/B test design: translate the qualitative signal into one specific, falsifiable claim, for example "removing the phone-number field from step 2 increases funnel completion rate." Primary metric: completion rate (users who finish the funnel divided by users who start it). Secondary metrics: time to complete, per-step drop-off, and a downstream quality check like day-7 activation, so a shorter funnel that quietly recruits lower-intent signups doesn't look like an unqualified win.

Reconciling conflicting results, before you're actually staring at a conflict: if qualitative flags a problem the quantitative test doesn't confirm (or the reverse), work through a short ladder rather than picking a side by instinct. First, check whether the qualitative sample was skewed (recruited mostly from power users, say). Second, check whether the test's minimum detectable effect was too coarse to see a small-but-real effect the interviews picked up. Third, if it's still genuinely unresolved, segment the quantitative data along the line the qualitative finding suggests (mobile users only, say) before concluding the two sources truly disagree.

Worked example

Baseline completion rate is 30%, and the team wants to detect a lift to 33% (a 3-point absolute, roughly 10% relative, improvement) at 95% confidence and 80% power:

$$n = \frac{\left(z_{\alpha/2}\sqrt{2\bar p(1-\bar p)} + z_\beta\sqrt{p_1(1-p_1)+p_2(1-p_2)}\right)^2}{(p_2-p_1)^2}$$

With $p_1=0.30$, $p_2=0.33$, $\bar p = 0.315$: the numerator works out to $(1.96 \times 0.657 + 0.84 \times 0.657)^2 \approx 3.38$, and dividing by $(0.03)^2 = 0.0009$ gives $n \approx 3{,}759$ per arm, about 7,518 signup attempts total. If roughly 500 people enter this step of the funnel per day, split evenly across the two variants (250 per arm per day), that's about 15 days to reach the required sample.

Trade-offs and pitfalls

Checking results before hitting that sample size inflates the false-positive rate, decide the stopping rule (a fixed sample size, or a proper sequential-testing correction) before the test launches, not after an early peek looks promising. A 3-point absolute lift on a 30% baseline is a real decision to make explicit: confirm that's the smallest lift actually worth shipping for, not just the number that was convenient to power for. And the day-7 activation guardrail exists specifically to catch a funnel shortcut that trades completion volume for user quality, for example dropping a legitimate qualifying question that later reduces spam or mismatched signups.

Direct answer

Compressing a three-month ramp into three weeks means deliberately not becoming broadly competent and instead becoming narrowly reliable on exactly what the project needs, while being explicit about what I'm skipping and how the resulting gap gets covered, whether that's a reviewer, a narrower scope, or stated uncertainty on anything I can't fully back. I would never let three weeks of learning quietly pass as equivalent to three months; the compression only works if everyone downstream knows what they're actually getting.

What compression actually means

Triage by what the project needs, not by the team's usual onboarding order. A normal three-month ramp typically builds broad familiarity before depth. With three weeks, I invert that: identify the two or three things this specific project actually requires me to be right about, and go deep only there, accepting shallow or absent knowledge everywhere else. If the timeline compressed further, to a single day, the triage gets sharper still: I would ask what one piece of context, if I got it wrong, would sink the project, and spend almost all the time there, explicitly skipping everything else rather than spreading thin.

Name the quality bars I refuse to drop even under compression. Compression is about learning less, not about shipping unverified work. I would still hold the same review and testing standards for anything I produce, even if the compressed ramp buys speed on learning but never on care.

Lean on other people's time, and be honest about the cost. The fastest lever available is borrowing a domain expert's attention instead of self-teaching everything from scratch, but that time is not free. I would be specific with the team about how much of someone's time I'm asking for and for how long, rather than letting it show up later as their own work quietly slipping.

Cover the gap with structure, not bravado. Where I know I'm still shallow, I build in a mandatory review step, narrow the scope of what I own until I catch up, or explicitly flag deliverables as carrying more uncertainty than the team's usual standard, rather than letting a compressed ramp quietly lower the bar without anyone deciding that on purpose.

Worked example

Joining a project three weeks before a launch, with the team's usual ramp closer to three months, I asked the lead directly what single area, if I got it wrong, would actually hurt the launch. The answer was one integration point with a partner system, so I deliberately left everything else about the surrounding codebase thin. I spent roughly half of the three weeks almost entirely on that integration, pairing daily with the engineer who owned it, which meant asking for about six hours a week of her time, made explicit up front rather than assumed. For the parts I stayed shallow on, I did not pretend otherwise: I flagged two areas in my own handoff notes as reviewed by me but not independently verified, and asked for an extra reviewer on anything touching them until I had more time. The launch shipped on schedule; the cost was that a change I made in one of the flagged areas weeks later took noticeably longer because I was still building real familiarity with it, a cost I had knowingly deferred rather than avoided.

Trade-offs and pitfalls

The core trade-off is depth for speed: three weeks buys narrow reliability, not the broad judgment three months would have given, and pretending otherwise is the real risk, not the compression itself. The most common pitfall is letting the compressed timeline quietly lower quality bars along with breadth, when only breadth should be sacrificed. A second pitfall is treating borrowed expert time as free; if it isn't planned and bounded, the person you leaned on absorbs the cost you didn't.

Direct answer

Changing a team's solution-first habit takes both a structural change (a lightweight artifact that makes framing visible and hard to skip) and a behavioral one (modeling and reinforcing the practice in the moments it matters most, like kickoff meetings), and either alone tends to fail: process without buy-in gets worked around, and buy-in without a structural forcing function fades under deadline pressure.

Structured elaboration

Tactical, structural change: introduce a lightweight "problem brief" that must be filled in and shared before any effort gets scheduled, with a small number of required fields (the problem, the evidence, who's affected) rather than a heavyweight document nobody will complete. Make it a genuine gate, work doesn't get calendared without it, not just a suggested best practice, because a non-enforced template gets skipped first under any deadline pressure.

Behavioral, meeting-level change: in kickoff meetings, ask "what problem does this solve, and how do we know" as the very first question, every time, consistently, until it becomes the team's own reflex rather than something only a lead asks. Use specific, non-judgmental scripts when a solution-first idea arrives ("that's a real idea, what's the underlying problem it addresses, so we can compare it against other ways of solving that same problem"), which redirects toward framing without dismissing the person's contribution.

Measuring adoption: track the share of new efforts that have a completed problem brief before work is scheduled (a simple, binary, easy-to-track process metric), and separately, spot-check a sample of briefs quarterly for actual quality, meaning whether the evidence field cites real data rather than being filled in as a formality after the fact, since a team can technically comply with a process metric while defeating its purpose.

Worked example

Three months after introducing the brief-before-scheduling gate and the kickoff-question habit, if 90% of new efforts have a completed brief (up from an informal baseline of roughly 20% before the change) but a quarterly spot-check finds a third of those briefs were filled in retroactively, after the work was already underway, that's a signal the structural gate succeeded at enforcement but the behavioral shift toward framing-first thinking hasn't fully taken, and it points at reinforcing the kickoff-meeting habit more directly rather than declaring the initiative complete based on the process metric alone.

Two complementary tactics belong alongside the template-and-meeting-structure approach above: a three-step coaching plan for individual contributors (a concrete exercise, a feedback ritual, and a tracked metric, repeated over three months) that builds the habit person by person, and a process for converting an existing backlog of solution-phrased requests into validated problem statements retroactively, with stakeholder workflows and guardrails so the backlog doesn't refill with the same pattern.

Trade-offs and pitfalls

A rigid, heavyweight brief requirement risks becoming exactly the kind of process theater it's meant to prevent, filled in after the fact to satisfy a gate rather than genuinely shaping the work; keeping the brief lightweight and the gate meaningfully enforced (not scheduling work without it, rather than just requesting it) is what keeps it from becoming theater. The behavioral change is the harder, slower half of this and is easy to under-invest in relative to the structural change, since a template is a one-time build while a habit shift requires sustained, repeated reinforcement over months.

Brief framing
Include accessibility testing as a core strand of usability research, not an afterthought. Treat it like any other persona-driven study with tailored recruitment, task adaptation, AT observation, and accessible reporting so teams can act.

Recruitment strategies

• Partner with disability orgs, community groups, rehab centers, and accessibility consulting pools.
• Offer multiple sign-up channels (phone, email, form) and clear inclusion criteria (types/severity of disabilities, assistive technology (AT) used, meaning tools like screen readers or switch devices that a participant relies on).
• Compensate fairly, provide travel or remote-stipend options, and schedule flexible times.
• Screen for AT familiarity and communication preferences; recruit a mix of primary and secondary AT users.

Task & consent adaptations

• Write consent in plain language; offer large-print, audio, or read-aloud options.
• Break tasks into smaller steps; allow participants to skip or pause.
• Use scenario-based tasks tied to real goals (e.g., complete purchase using screen reader) and let participants demonstrate their regular workflows.
• Allow proxy facilitation for communication disabilities (e.g., support person), documenting assistance.

Assistive technology considerations

• Observe and record participants' native AT, settings, browser and OS versions, and custom configurations.
• Test in participants' environments when possible; provide a lab with common AT (JAWS, NVDA, VoiceOver, ZoomText, switch devices) for comparability.
• Have an accessibility-savvy facilitator to avoid interrupting flows; capture audio, video, and AT output (e.g., screen reader audio transcripts).

Presenting findings to product & engineering

• Prioritize findings by severity, frequency, and business impact; include quick wins and systemic issues.
• Deliver artifact-driven reports: short executive summary, concrete user stories, video clips of failure modes, step-by-step repros, and recommended acceptance criteria.
• Map issues to components, include estimated effort/risk, and suggest regression tests and AT-supported automated checks.
• Advocate for inclusive design patterns, share participant quotes, and propose success metrics (e.g., task completion rates for AT users, reduced support tickets).

End with a concrete next step: recommend running an accessibility-focused moderated test early in the next sprint and pairing designers with an AT-using participant for co-design.