← Zoox Interview Insights

Zoox·Machine Learning Engineer·Technical Phone Screen·Senior

Senior
Jun 2026

Summary

Zoox ML engineer interview had a coding problem that looked like a simple list-processing task but turned into a full OOD design discussion. The follow-up about extensibility was where things got interesting, and honestly where I felt least prepared.

Questions Asked (2)

Q1

Given a list of roller coaster descriptions each containing type, max speed, bumps per second, and lift type, compute an overall score for each coaster using a formula that varies by coaster type. Return the scores as formatted strings rounded to one decimal place.

Algorithms & Data StructuresTechnical Trade-offs
Author's notes

I got the mechanics down pretty fast.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify the scoring formula for each coaster type and the expected output format, then design a modular solution that maps coaster types to scoring functions, computes scores, and formats them to one decimal place. Discuss trade-offs between extensibility and simplicity, and validate with edge cases.

Pro tip: Proactively discuss how you would handle ambiguous or missing formula details, and suggest a configuration-driven approach to easily update formulas as requirements evolve.

1. Clarify Requirements

Ask about the exact scoring formula for each coaster type, the input format, and any constraints (e.g., missing data, performance). Confirm the output format: a list of strings rounded to one decimal place.

2. Design Data Structures

Define a data structure to represent each coaster (e.g., a class or dictionary) and a mapping from coaster type to a scoring function. Consider using a strategy pattern or a dictionary of lambdas for extensibility.

3. Implement Scoring Logic

For each coaster, look up the appropriate scoring function based on its type, compute the raw score, and round to one decimal place. Handle edge cases like unknown types or missing fields.

4. Format and Return Results

Convert each score to a string with exactly one decimal place (e.g., using f-strings or format specifiers) and return the list of formatted strings.

5. Test and Validate

Write unit tests covering all coaster types, edge cases (e.g., zero values, negative numbers), and verify rounding behavior. Discuss time and space complexity.

Key Points to Mention

  • Modular design: separate scoring logic per coaster type for maintainability and extensibility.
  • Use of a dictionary or strategy pattern to map types to functions, avoiding long if-else chains.
  • Rounding to one decimal place: use round() or format strings, and be aware of floating-point precision issues.
  • Edge case handling: unknown coaster types, missing data, or invalid inputs.
  • Time and space complexity: O(n) time for n coasters, O(1) extra space per coaster.
  • Testing: unit tests for each type and boundary conditions to ensure correctness.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.

Q2

How would you redesign the solution so that adding new coaster types or changing scoring rules doesn't require modifying the core processing logic?

System DesignTechnical Trade-offs
Author's notes

This is where I fumbled a bit.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by identifying the core processing logic and the varying parts (coaster types, scoring rules). Then propose a design that separates these concerns, such as using the Strategy pattern for scoring and a Factory or plugin architecture for coaster types, ensuring the core logic depends on abstractions. Emphasize how this adheres to the Open/Closed Principle and facilitates extensibility without modifying existing code.

Pro tip: Mention that in ML systems, this often translates to configurable pipelines and modular components, and that you would validate the design with unit tests for each new component to ensure the core remains untouched.

1. Identify core vs. variable logic

Analyze the current solution to distinguish the stable core processing logic from the parts that change when adding coaster types or altering scoring rules.

2. Define abstractions

Introduce interfaces or abstract classes for coaster types and scoring rules, so the core logic depends on these abstractions rather than concrete implementations.

3. Apply design patterns

Use appropriate patterns: Strategy for scoring rules, Factory or Registry for coaster types, and possibly Dependency Injection to wire components together.

4. Implement plugin architecture

Allow new coaster types and scoring rules to be added as plugins or modules that conform to the abstractions, without modifying the core processing logic.

5. Ensure testability and validation

Write unit tests for each new component and integration tests to verify that the core logic remains unchanged and works with new extensions.

Key Points to Mention

  • Open/Closed Principle: open for extension, closed for modification
  • Strategy pattern for interchangeable scoring algorithms
  • Factory or Abstract Factory for creating coaster types
  • Dependency Injection to decouple core logic from concrete implementations
  • Plugin or modular architecture for dynamic loading of new types
  • Configuration-driven approach to define scoring rules without code changes

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.