Applied·Machine Learning Engineer·Technical Phone Screen·Intermediate

Intermediate

Jun 2026

Summary

Applied gave me a technical screen for an ML Engineer role that turned into a pretty involved coding problem about schema validation. No fluff, just code. The problem was well-scoped but had enough edge cases to keep you honest.

Questions Asked (1)

Given a set of custom descriptor objects that define an expected schema, implement a validator that checks whether an input configuration matches the descriptor. The validator should handle primitives, nested objects, and lists, and return a list of errors that include field paths and type information.

Algorithms & Data StructuresSystem DesignTechnical Trade-offs

Author's notes

This one took me a minute to fully parse.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the descriptor format and error reporting requirements, then outline a recursive validation strategy that handles primitives, nested objects, and lists. Emphasize extensibility and clear error messages with field paths, and discuss trade-offs like performance and schema evolution.

Pro tip: Design the validator to be easily extensible for new types and consider using a visitor pattern or type registry to avoid deep if-else chains. Also, ensure error paths are dot-separated and include indices for lists to make debugging easier.

1. Clarify requirements and assumptions

Ask about the descriptor format, expected error structure, and whether the schema can evolve. Confirm handling of edge cases like null, missing fields, and extra fields.

2. Design the validation architecture

Propose a recursive validator that dispatches based on descriptor type. Use a registry or strategy pattern to map types to validation functions, ensuring extensibility.

3. Implement core validation logic

For primitives, check type and constraints; for objects, iterate over descriptor fields and recurse; for lists, validate each element and track index in the path.

4. Handle error aggregation and reporting

Collect errors in a list, each with a field path (e.g., 'user.address.street') and expected vs actual type. Ensure paths are built correctly during recursion.

5. Discuss trade-offs and optimizations

Mention performance considerations (e.g., early exit vs full error collection), schema evolution (backward compatibility), and potential caching of compiled schemas.

Key Points to Mention

Recursive validation with type dispatch (e.g., using a registry or visitor pattern)
Error object structure: field path, expected type, actual type, and error message
Handling of nested objects and lists, including index tracking in paths
Extensibility for custom types and constraints (e.g., regex, min/max)
Trade-offs: early exit vs collecting all errors, performance vs completeness
Schema evolution and backward compatibility considerations

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