Senior UI Designer Interview Preparation Guide for Google

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.

Situation / Goal
I led UI across web and native apps for a product family where visual drift and inconsistent responsive behavior slowed releases and increased dev rework. My goal: preserve responsive integrity while letting designers iterate quickly.

Process & Governance

• Establish a living Design System in Figma with tokens (color, type, spacing, breakpoints) and component variants for web, iOS, Android.
• Define responsive rules tied to tokens: 4 breakpoint groups, fluid spacing scale, and accessibility thresholds.

Review Cycles

• Two-tier reviews:
  • Lightweight daily syncs / Figma comments for iterative work (designers own rapid exploration).
  • Weekly formal component review with lead + dev + QA for any new/changed components affecting responsiveness or tokens.
• Use a PR-like flow (PR stands for pull request, the code-review workflow developers use before merging a change): submit a "Design Change Request" in a lightweight template (what changed, affected tokens, screenshots across breakpoints, implementation notes).

Documentation Standards

• Component pages include: purpose, anatomy, props/variants, responsive behavior examples, token mappings, code snippets, and QA checklist.
• Maintain a changelog and migration notes for token changes.

Example & Outcome
By enforcing token-driven components and the two-tier review, we reduced CSS override bugs by 60% and sped up design iteration: designers could prototype freely while major changes passed the weekly gate for consistency.

Direct answer

In the room, your only job is to keep the discussion useful: acknowledge the feedback without getting defensive, ask questions that turn a blunt opinion into something specific enough to act on, and separate "hearing the criticism" from "agreeing to act on it." Write it down precisely and neutrally so the team has a record, then run a short process afterward to decide, with evidence, whether to incorporate or reject it.

Structured elaboration

In the room (keep it constructive)

• Acknowledge before defending: thank them for the input, even if the delivery was harsh. This is not agreement, it just keeps the room from turning defensive.
• Convert opinion into specifics: ask "which screens or elements feel that way to you?" or "what would this look like if it worked?" A comment like "this looks unprofessional" is not actionable until you know if it is about hierarchy, copy, spacing, or color.
• Protect the room: if the stakeholder's tone starts shutting other people down, redirect ("that's a useful challenge, let's hear how others read it too") instead of either siding with them or arguing back.
• Commit to a process, not a verdict: close with "I'll capture this, look into it, and bring back options" rather than caving on the spot or dismissing it outright.

Documenting the feedback for the team
Capture it as a structured note, not a paraphrase: who said it, the exact quote, which screens or elements it points to, and what outcome would resolve it. Attach it to the specific frame or comment thread in the design tool so it stays linked to the actual artifact, not floating in a meeting doc nobody reopens.

Follow-up: incorporate or reject, with a rationale trail

• Triage first: is this a one-off opinion, or does it match other signals, such as past usability findings, support tickets, or other reviewers?
• If there is no existing evidence either way, get some. A quick heuristic review or a small usability check, even with a handful of users, can surface whether a real problem exists before you commit engineering time.
• Decide and write down why. If you incorporate the feedback, name the evidence that tipped the decision. If you reject it, document the evidence and reasoning just as explicitly, not "we decided not to," so the next person who reopens the thread understands the call was reasoned, not political.

Worked example

A senior stakeholder says in critique: "This dashboard looks confusing and unprofessional." In the room: "Thanks, that's useful. Can you point to what feels confusing, is it the layout, the labels, or something else?" They say the metric cards feel cluttered. You reply: "Got it, I'll dig into that and bring back options next week."

Documented note: "Senior stakeholder (critique): 'looks confusing and unprofessional,' specifically the metric-card cluster on the dashboard home screen. Resolution target: reduce visual density without losing the data shown."

Follow-up: you run a quick cognitive walkthrough (stepping through the task as if you were a first-time user) with two teammates unfamiliar with the screen; both also hesitate at the same card cluster, which corroborates the stakeholder's read. You simplify the cards to one primary number each, cut two of five cards, and present the before and after at the next critique with the corroborating note attached. Result: the feedback is incorporated because a second, independent check backed it up, not simply because a senior person said it.

Trade-offs and pitfalls

• Caving immediately just because of seniority risks building on unvalidated preference. Refusing to even look into it risks ignoring a real blind spot and damaging the relationship.
• Do not soften the quote when documenting it. "Leadership had concerns" throws away the specific information a future reader needs.
• A single opinion is real data, not proof. Treat it as a hypothesis worth testing, not a verdict to either obey or dismiss.

Direct answer. WCAG has two target-size criteria at different levels, and they are not interchangeable: SC 2.5.8 Target Size (Minimum), added in WCAG 2.2, is Level AA and is the actual compliance floor most organizations are legally bound to (24x24 CSS pixels, with exceptions for inline targets, user-agent-controlled sizing, and targets spaced at least 24px from their neighbors). SC 2.5.5 Target Size (Enhanced) is the older, stricter Level AAA criterion at 44x44 CSS pixels with no spacing escape hatch. Platform guidance (Apple Human Interface Guidelines, Android Material Design) independently converges close to the AAA figure, roughly 44x44 CSS pixels, with at least 8px of spacing between adjacent targets, because fingertip contact area is meaningfully larger and less precise than a mouse pointer, and motor-impaired users need even more margin for error. In practice: treat 24x24 as the legal floor and 44x44 as the number you actually design to, since it is also what the platform guidelines independently recommend.

Why visual size and hit area can differ. A visually small icon (say 16x16px) can still meet the 44x44 requirement by having generous invisible padding around it that extends the clickable/tappable region without changing how large the icon looks, which is the standard technique for keeping a dense visual design while still passing the target-size requirement.

Documenting requirements for designers and developers. State the number as a hard floor in the design system ("44x44px minimum, 8px minimum spacing") attached to the interactive-component tokens, not as a general guideline in a separate document; specify it in both CSS pixel and physical measurement terms if the product spans web and native, since native platforms sometimes express the guidance in points/dp rather than raw pixels and a naive 1:1 translation across platforms can under-size the target.

Platform-specific notes. iOS Human Interface Guidelines recommend a minimum of 44x44pt; Android Material Design recommends 48x48dp; both are close to but not byte-identical to the WCAG 44x44 CSS-pixel figure, and a cross-platform design system should pick the stricter of the applicable platform guidance rather than the loosest.

Trade-offs and pitfalls. Density-focused designs (data tables with many small icon-only actions per row) are in real tension with this requirement; the usual resolution is a slightly taller row on touch/mobile breakpoints specifically, or converting inline icon actions into a single overflow "more actions" menu on small viewports rather than trying to fit six 44px targets in a row that was designed for a mouse.

Direct answer

Of the four, Figma is the safest default for team-based ideation and prototyping today because of its real-time collaboration and cross-platform reach. The other three each make sense in narrower cases, and it's worth being upfront that two of them have shifted position since they were the obvious comparison set: Adobe XD is now in maintenance mode, Adobe confirmed in 2024 it isn't investing in new features while continuing basic support, and Framer has evolved from a pure interaction-prototyping tool into primarily a no-code website builder. Comparing them purely "for prototyping" needs that caveat for both.

Comparison

Mid-fidelity framing

For a mid-fidelity round meant for stakeholder presentation and early user testing rather than final visual polish, Figma or Sketch are both fast enough to build and revise in, while Adobe XD and Framer are better saved for later, higher-fidelity stages given the trade-offs above.

Trade-offs and pitfalls

Choosing a tool based on its reputation from a few years ago rather than its current state is a real risk here specifically, since two of these four have meaningfully repositioned. Before standardizing a team on Adobe XD or Framer for prototyping, check what each tool is for today, not what it was known for when the comparison was first made.

Direct answer

A dedicated ideation phase exists to widen the option space before you commit build resources to any one direction. Prototyping tests a specific idea in enough fidelity to learn from; ideation generates the population of candidate ideas you choose that direction from. If you skip straight to prototyping, you are only ever testing the first plausible idea, not comparing it against anything.

Structured elaboration

Definitions

• Ideation: rapidly generating many candidate directions, in whatever medium is cheapest to produce and throw away.
• Prototyping: building a testable, sufficiently real version of one selected idea, to learn something a sketch cannot tell you (how it actually feels to use, whether it holds up under real data).

Why speed and quantity beat polish at this stage

• Cost of change: a sketch costs minutes to discard; a build costs days or weeks. Ideation deliberately stays in the cheap zone for as long as possible.
• Anchoring: a polished mockup signals false confidence and pulls reviewers toward evaluating the visual execution instead of the underlying idea.
• Coverage: generating more candidates raises the odds that a non-obvious, better direction is even in the room to be considered.

What you actually walk away with
Not a single deliverable, but a small set of genuinely distinct directions (not five variations on one idea), plus a record of what was considered and ruled out and why. That shortlist is what feeds the convergence step, where one or two directions get selected to prototype.

Common tools and when to reach for each

The analog-to-digital move matters for remote teams specifically: sketch fast on paper (it's still faster than a mouse for early divergence), then photograph or re-draw into the shared board so distributed participants can cluster and vote on equal footing.

Worked example

Given a brief to redesign a dashboard's data-summary card, a facilitator runs a fifteen-minute timeboxed round: each participant sketches three layout variants on paper (grid, list, hybrid) without discussion. Sketches are photographed into a shared Miro board so remote participants can see them alongside in-room ones. The group clusters similar sketches, discusses briefly, and picks one direction to carry into Figma for a clickable prototype. Nothing was built in Figma until a direction had already survived divergence and a first round of group discussion.

Trade-offs and pitfalls

• Skipping ideation and prototyping the first idea anchors the team early and means any later usability test is only ever confirming or denying one option, not comparing options.
• Running ideation with no convergence step afterward produces a pile of sketches and no decision; ideation needs to end in a shortlist, not just stop.
• Reaching for a high-fidelity tool too early (styled Figma components during divergence) tends to seduce the group into polishing one idea instead of generating several.

When it's acceptable to deviate

Deviations are allowed when they materially improve user outcomes or enable urgent product needs that the system cannot reasonably support: e.g., accessibility fixes, unique brand moments, regulatory requirements, or a prototype that must validate a novel interaction. Deviations are not for arbitrary visual preference or one-off polish.

Governance process to approve an exception

1. Request: Designer files an Exception Request with context (user problem, screenshots, proposed change, alternatives considered).
2. Review: Design System Committee (lead designer, front-end engineer, product manager, accessibility lead) triages within 2 business days.
3. Evaluation: Use criteria—user impact, technical cost, accessibility, reusability, frequency, and alignment with brand.
4. Decision: Approve / Approve with constraints / Reject. If approved, assign owner and sunset criteria (when to merge back).
5. Implementation: Developer pair implements a namespaced component and feature-flag if needed.

Capturing the deviation

• Create a living “Exceptions” registry in the design system (component entry): motivation, screenshots, code snippet, owner, expiry/sunset date, and link to issue.
• Tag components in Figma and code with an “exception” badge and include migration tasks in the backlog.
• Schedule quarterly audits to reduce fragmentation and either reconcile approved patterns into the system or retire them.

Why this works

This preserves consistency while allowing pragmatic flexibility: every deviation is visible, accountable, and has a plan to either generalize or sunset, preventing long-term fragmentation.

Direct answer
Ramping someone from day one to their first shipped work is a deliberate sequence, not a single onboarding checklist: assess what they actually already know, give them small real tasks with tight review loops before a full feature, gradually widen the scope of ownership, and define upfront what "shipped" and "done" mean so the finish line is unambiguous. The plan should look different depending on who's arriving, not just be a fixed template applied to everyone.

Structured elaboration

The default arc

• First few days: orient and assess. Don't assume a blank slate; find out what they already know so you're not re-teaching things or, worse, skipping things they actually need.
• Early tasks: small, real, low-blast-radius work with fast, close review. The goal here is confidence and calibration to the team's standards, not speed.
• Middle stretch: progressively larger scope with more independence, review shifting from "check everything" to "check the risky parts."
• First real shipped piece: something end-to-end they own, with you available but not doing it alongside them, and a clear definition of "done" agreed before they start, so success isn't a moving target.

Adapting the plan to who's actually arriving

This is where a generic checklist breaks down, and it's the part that separates a senior answer:

• A contractor under least-privilege or compliance constraints: access is scoped down from day one, so the plan has to work around what they legitimately can't see or touch, and documentation often needs to be more explicit since they can't casually ask around as easily as a full-time hire embedded in the org.
• A career-changer from an adjacent discipline (a backend engineer moving into data engineering, a research scientist moving into production ML): they're not a blank slate, they have real transferable skills. The plan should explicitly identify what carries over and target ramp-up specifically at the actual new-domain gaps, not restart from zero the way you would for someone with no relevant background.
• A cohort of remote interns rather than one hire: 1:1 pairing time doesn't scale to a group. The plan shifts toward a shared structured curriculum, peer learning between the interns, and scheduled office hours, with 1:1 time reserved for the things that genuinely need it.
• A remote hire versus a senior IC joining: a remote hire needs more of everything written down explicitly, since the informal hallway learning that fills gaps for an in-person hire doesn't happen by accident. A senior IC's gap is usually organizational context and relationships, not raw skill, so their plan should be lighter on procedural scaffolding and heavier on introductions, context on how decisions get made, and where the landmines are.

Worked example

Situation

I mentored someone joining as an individual contributor with solid general skills but no exposure to our specific stack or codebase, with a goal of them shipping one real, complete piece of work within their first several weeks.

Action

Week one was mostly orientation and a short assessment task to see where they actually stood, not a generic reading list. From there, I gave them a small real bug fix with a tight review loop so they got fast, specific feedback on our conventions early, before those habits calcified the wrong way. Over the following weeks the scope widened: a small self-contained feature with me reviewing closely, then a larger piece with me available but stepping back from line-by-line review, focusing instead on the riskiest parts of the design.

Result

They shipped a real, complete piece of work end-to-end within the target window, with a review pass that looked much closer to how we review any other team member's work by that point, which was the actual signal of readiness, not just that the calendar had passed.

Trade-offs & pitfalls

• Treating every new hire's plan as the same template. A junior mentor runs the same onboarding for a contractor, a career-changer, an intern cohort, and a senior IC. A senior mentor adapts the shape of the plan to who's actually arriving, because the actual gap being closed is different in each case.
• Under-scoping early tasks out of excessive caution, or over-scoping out of impatience. Both undermine the confidence-building purpose of the early stretch: too small and it's condescending or boring; too large too soon and the first review becomes overwhelming and demoralizing.
• Not defining "done" up front. Ambiguity about what counts as finished either causes needless rework or lets something ship that isn't actually ready, and both erode trust in the mentoring relationship.
• Ignoring the constraints a nontraditional hire is actually operating under. Applying a full-access, in-person, junior-IC plan to a least-privilege contractor or a remote hire sets them up to fail on logistics that have nothing to do with their actual skill.

Direct answer

Accessibility regressions need the same discipline as any other guardrail metric (a metric you are not trying to improve, but must not let get worse): catch as much as possible automatically before code merges, treat accessibility as a guardrail inside every A/B experiment (not a separate audit that happens later), and pre-commit to a rollback threshold so a regression gets reverted by a rule, not by whoever happens to notice a complaint. Automated tools alone are not enough, since categories like logical reading order or whether alt text is actually descriptive cannot be checked by a DOM scanner, so human and assistive-technology validation stay mandatory, not optional.

Structured elaboration

Automated checks (continuous, in CI, meaning continuous integration, the automated pipeline that runs checks on every code change, and staging):

• Run an automated scanner (for example axe-core or Lighthouse's accessibility audit) on every pull request, checking against WCAG (Web Content Accessibility Guidelines, the standard accessibility rules for web content) success criteria like color contrast, missing form labels, and ARIA (Accessible Rich Internet Applications, the attribute set that describes custom interactive elements to assistive technology) attribute misuse. Block the merge on any new critical or serious violation.
• In production, track a small set of runtime accessibility signals continuously: keyboard-only task completion rate (can a user complete the flow using only Tab and Enter), screen-reader announcement failures (an ARIA live region that should announce a state change but silently doesn't), and focus-trap errors (focus getting lost or stuck, especially in modals).

Human validation (scheduled, not one-off):

• A manual audit by someone trained in accessibility at each major release milestone, since automated scanners cannot judge things like whether the reading order makes sense or whether alt text actually describes the image rather than just existing.
• Periodic sessions with people who actually rely on assistive technology (screen reader users, switch-device users, keyboard-only users), since a compliant DOM can still be a confusing or exhausting experience to navigate for real.

Instrumenting A/B experiments specifically:

• Add the runtime accessibility signals above as guardrail metrics on every experiment touching the UI, exactly like you would guardrail page load time or revenue. An experiment is only allowed to ship if its treatment arm doesn't regress those guardrails beyond a pre-agreed threshold, regardless of how the primary metric performs.
• Segment experiment guardrails specifically for assistive-technology traffic (users whose client signals screen-reader or switch-device use) where that signal is available, since an aggregate guardrail can look fine while a small, high-need segment is badly broken.

Rollback and mitigation:

• Ship UI changes behind a feature flag so a regression can be reverted for 100% of the treatment population within minutes, not through a new deploy.
• Pre-commit to a numeric rollback rule before launch (see the worked example) so the decision to revert isn't a judgment call made under pressure after the fact.
• After any rollback, run a structured post-mortem: what the automated scan missed, why, and whether that gap should become a new automated check or a new item on the manual audit checklist.

Worked example

An illustrative pre-commit rollback rule for a new checkout flow experiment: the keyboard-only task completion rate for the control arm is measured at 92%. The guardrail threshold is set at "no more than a 5 percentage point drop." Post-launch monitoring shows the treatment arm at 81%, an 11-point drop, which breaches the 5-point threshold, so the experiment auto-halts and the flag reverts to control for all users while the team investigates. In this illustrative case, the root cause turned out to be a new custom dropdown that swallowed the Tab key, invisible to axe-core's automated scan because the dropdown was implemented with a non-semantic <div> and no ARIA role, exactly the class of issue only a keyboard-only guardrail metric or a manual audit would catch.

Trade-offs and pitfalls

Automated checks are cheap and fast but only catch what they're built to check; treating a clean axe-core report as proof of accessibility is a common and dangerous shortcut. Manual audits catch more but don't scale to every pull request, which is why both layers are needed rather than either alone. Setting the rollback threshold too tight causes constant false-alarm reverts on noisy metrics; setting it too loose lets real regressions ship for days before anyone notices, so the threshold itself should be revisited using the variance seen in past A/A tests on that same metric, not picked arbitrarily.

Direct answer

I'd evaluate the request on three axes, reach (how many teams actually need this), fit (does the requested behavior still satisfy the design system's contracts around accessibility, theming, and the existing API's mental model), and cost (what maintaining a divergence costs the system long-term), and use those to route to one of three outcomes: extend the core Table if the need is broad and still fits the contract, grant a time-boxed exception if it's narrow and low-risk, or spin off a separate package if the performance or rendering model is fundamentally different from what the core Table was built to do. The default bias is toward keeping one accessible, well-tested Table implementation; a separate package is a real cost, not a free escape hatch.

Structured elaboration

Decision flow

flowchart TD
  A[Request: custom table behavior conflicts with system API] --> B{Common need across many teams?}
  B -- Yes, broad reach --> C{Still fits system's accessibility and theming contract?}
  B -- No, niche --> D[Exception: time-boxed and documented]
  C -- Yes --> E[Extend the core Table API]
  C -- No, different rendering model --> F[Separate package]
  D --> G[Review at expiry: retire or promote to extension]
  F --> H[Share design tokens and UX patterns]
  E --> I[Add tests, docs, versioned release]

Criteria

Why cost matters more than the first request looks

The tempting failure mode is treating "extend" as always the generous, collaborative answer. It isn't, if the requested behavior only serves one team and pulls the shared Table's API surface in a direction that makes it harder to reason about for everyone else, that's a cost paid by every future consumer, not just the requester. Conversely, refusing everything into "separate package" avoids core API bloat but risks fragmenting the product's table experience into several inconsistent widgets that all happen to be named Table.

Worked example

Concrete scenario: a team needs a table rendering 100k rows with custom cell virtualization and inline editing at 60fps-class responsiveness, and the core Table's DOM-based row virtualization can't hit that without a different rendering strategy (windowed canvas or a virtualization library with a different focus-management model).

Applying the criteria: reach is moderate (this team plus two others doing similar dense-data views), fit fails on the accessibility axis specifically because the performance approach requires bypassing the core Table's DOM-based focus and ARIA row model, not because anyone dislikes it. That combination (real reach, but a genuine structural fit failure) routes to separate package, not extend and not exception: extend would force the accessibility compromise onto every core Table consumer, and exception would leave three teams re-solving the same problem independently within a year. The separate package still imports the system's design tokens (spacing, typography, color) so it looks and feels like the same system, it just isn't the same component underneath, and its existence gets documented in the system's component index so the next team with a similar need finds it instead of building a fourth table.

Trade-offs & pitfalls

• Exceptions are the easiest option to grant and the easiest to regret: without an actual expiry date and a named owner for the review, "temporary" exceptions become permanent forks that nobody revisits, which is worse for the system's integrity than either a deliberate extension or a deliberate separate package.
• A separate package is not free just because it's not touching the core API: it still needs its own accessibility audit, its own token consumption discipline, and a place in the system's documentation, or it becomes exactly the kind of undocumented one-off the system was built to prevent.
• The failure mode on the "extend" side is API creep: each individually reasonable prop addition is easy to approve, but a Table that's accumulated a dozen conditional behaviors to satisfy every past exception request becomes hard for anyone to reason about, which is its own maintenance cost that rarely gets attributed back to the decisions that caused it.
• A senior answer names the re-evaluation trigger up front (a separate package that gains enough adoption should periodically be reconsidered for promotion into the core system, and an exception that's still active a year later is a signal the criteria were applied wrong the first time), rather than treating the decision as made once and never revisited.