Editorial practice groupings, not verified official interview questions or endorsements.
Public Waymo prep guide
Prepare with five practice prompts shaped by one public account of a 2026 senior frontend loop: a tree filter rendered as UI, an Angular screen fixed from user bug reports, a TypeScript Promise problem, the frontend of an AI chat application, and an autocomplete search bar with debounce.
This guide uses a public, self-reported interview account to create realistic constraints. It does not claim access to private interview material, a fixed interview format, or the stack of every Waymo team.
Study priorities
The reported loop rewards engineers who state a contract before writing code: what a filter removes, which state owns a list, what happens to a reply when the user presses Stop. Each prompt below starts with the clarifying questions a strong candidate asks, then the behaviours a strong answer covers, then the miss that usually ends the round.
Treat the report as a shape, not a script. The phone screen rendered a filtered tree as UI; the onsite mixed debugging, a Promise exercise, system design and a timed UI build. Practice those shapes in your own stack first, then once in Angular, because the May 2026 posting asked for production Angular experience.
Role lenses
These are preparation lenses derived from the public report and the kinds of screens an autonomous-driving company runs, not claimed team assignments. Choose the lens closest to the role and keep the reasoning framework-neutral.
The reported loop came from a simulation team: data-dense screens, trees and tables of runs, filters that must stay truthful, and bug reports from engineers who use the tool all day.
Practice focus: Derived state, filtering and tree rendering, explicit empty and error states, reproducing bugs from reports, and keeping a screen responsive with large lists.
Fleet and operations views combine live status, retries against flaky services and operator actions that must never fire twice.
Practice focus: Request ownership and cancellation, idempotent actions, reconnect and retry rules, and accessible controls that an operator can drive from the keyboard.
Representative practice prompts
For each prompt, clarify the contract, explain ownership and trade-offs, implement or diagram the smallest credible slice, and test the failure cases. Each prompt links to the public report it is modelled on and to a runnable practice page.
Prompt 1
Given an n-ary tree of named nodes and a search term, drop every node whose name contains the term together with its subtree, then render what remains so the hierarchy stays readable.
Practice version modelled on a reported round: Public report: Waymo senior frontend engineer loop, May 2026
Recursion or explicit stacks, pruning at visit time, order and indentation contracts, immutability, and whether you ask about case sensitivity and the empty term before coding.
Common miss: Filtering children after rendering, which keeps the grandchildren of a pruned node alive, or letting an empty term prune the whole tree because every string includes the empty string.
Practice the tree filter with testsPrompt 2
You receive an Angular app and three short reports from people who use it. Reproduce each report, find the root cause, fix all three, and explain what you changed without breaking the existing behaviour.
Practice version modelled on a reported round: Public report: Waymo senior frontend engineer loop, May 2026
Reading unfamiliar component and template code, turning a report into a reproduction, derived-state and event-binding reasoning, and communicating a root cause rather than a symptom patch.
Common miss: Patching the symptom, for example resetting a flag in the click handler, while the derived-state bug that caused it stays in place.
Debug the fleet status board (Premium)Prompt 3
The report says a pure TypeScript Promise problem was asked and does not say which. Prepare the family: build a deferred promise, implement Promise.all with ordering and fail-fast semantics, and add cancellation or timeouts without breaking Promise rules.
Practice version modelled on a reported round: Public report: Waymo senior frontend engineer loop, May 2026
Microtask timing, settlement rules, typed generics, error propagation, and whether you can explain adoption of a thenable and first-settlement-wins behaviour.
Common miss: Resolving with an array that fills in completion order, or letting a second resolve call overwrite an already settled value.
Practice the deferred promise drillPrompt 4
Design the composer, the streaming reply and the conversation state for an AI chat product: one active reply at a time, Send that becomes Stop, retries that never duplicate a turn, and stale stream events that cannot touch the new turn.
Practice version modelled on a reported round: Public report: Waymo senior frontend engineer loop, May 2026
State ownership across input, drafts, uploads and the active turn; stream and command identity; cancellation and recovery; and accessibility of streamed text.
Common miss: Treating a local abort as a confirmed server Stop, so a late chunk from the old stream mutates the new reply.
Work through the AI chat composer casePrompt 5
Build a search box that suggests results as the user types, waits for a pause before requesting, ignores stale responses, and stays usable from the keyboard.
Practice version modelled on a reported round: Public report: Waymo senior frontend engineer loop, May 2026
Timing control, request ownership and cancellation, keyboard and listbox semantics, and truthful loading, empty and error states.
Common miss: Treating debounce as the race-condition fix while an older response or a finally block still overwrites the current query.
Practice the React autocomplete starterPublic mini walkthrough
Treat this as a representative exercise, not a description of the reported screen. Work from the contract toward the traversal, and say each decision out loud.
Substring, case-sensitive, and an empty term keeps everything. Say it, then write it as the first guard.
This prompt prunes: a matching node takes its subtree with it. The opposite filter, keeping ancestors of a match, is a different traversal; name the difference.
Depth-first, siblings in order, depth carried along. Rendering text or nested list items is the same walk with a different emit step.
Matching root, empty term, deep nesting, a leaf without children, and the input left untouched.
Actionable preparation
Every day ends with code, a test, a design artifact, or a question you can use in the real process.
Tree traversal: recursive and stack-based walks, prune at visit time, render text and nested lists.
Deliverable: The tree filter passing all eight tests in both forms.
Derived state: lists computed from a source, flags assigned rather than toggled, duplicate handlers.
Deliverable: A written root cause for each of the three fleet-board reports.
Promises in TypeScript: deferred, Promise.all ordering, first settlement wins, microtask timing.
Deliverable: A typed Promise.all with tests for order and fail-fast.
AI chat frontend: identities for sends and streams, Stop versus abort, resume rules.
Deliverable: A one-page state and recovery diagram for the composer and active turn.
Autocomplete: debounce, latest-request guard, combobox semantics, failure states.
Deliverable: The autocomplete starter with out-of-order responses handled.
Angular pass: rebuild the tree filter and the autocomplete as standalone components with signals.
Deliverable: Two small Angular components with behaviour checks.
Mock loop: one timed build, one debugging session from a bug report, one design walkthrough, each narrated.
Deliverable: A list of the questions you will ask the recruiter about format, tools and stack.
Preparation FAQ
No. They are FrontendAtlas practice versions modelled on round types described in one public, self-reported account. The wording, the data and the test cases are ours.
The May 2026 posting behind the report asked for production Angular experience and the onsite included an Angular debugging round. One report cannot establish the stack of every team; confirm it with the recruiter and prepare the same contracts in your own framework first.
The report only says a pure TypeScript Promise problem. Prepare the family: deferred promise, Promise.all semantics, and cancellation or timeout follow-ups.
It describes one loop in May 2026. Interview formats change by team and over time, so treat it as a shape to practise, not a schedule to expect.
Free public practice
These public pages cover the traversal, async, debugging, design and communication skills used by the practice prompts. They are supporting drills, not claimed Waymo questions.
Public interview reports and official context
These links support the public context used by the guide. Their notes state what each source can and cannot establish about preparation.
One self-reported senior loop from a simulation team. It establishes the round types this guide is modelled on; it cannot establish exact wording, the current format or the stack of other teams.
Official roles and teams for product context only, not evidence of interview content or format.
Full company practice
This public guide is complete enough to plan a focused week. Premium unlocks the Angular debugging exercise, the Promise.all implementation and the broader company-tagged editorial set.