Applied intuition·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say

Apr 2026

Summary

Applied Intuition SWE interview with a schema validation problem that's less algorithm-heavy and more about careful parsing logic. The problem itself isn't hard conceptually but there are enough edge cases to trip you up if you're not methodical.

Questions Asked (1)

Given a schema that describes fields with types and optional/required flags (similar to protobuf), write a function that validates whether a JSON document conforms to that schema, including handling nested message types and rejecting unknown fields in strict mode.

API & IntegrationsAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

The recursion part is where I fumbled a bit.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the schema format and strict mode behavior, then outline a recursive validation function that traverses the JSON document alongside the schema. Emphasize handling nested types, optional/required fields, and unknown field rejection, and discuss trade-offs between strict and lenient modes.

Pro tip: Mention that you would validate incrementally and collect all errors rather than failing fast, which is more useful for debugging and aligns with production-grade validators. Also, highlight the importance of distinguishing between missing optional fields and null values.

1. Clarify requirements and schema representation

Ask about the schema format (e.g., JSON Schema, protobuf-like) and strict mode semantics. Confirm how nested types and optional/required flags are represented.

2. Design recursive validation function

Outline a function that takes a schema node and a JSON value, checks type compatibility, and recurses into nested objects or arrays. Handle optional fields by allowing absence, and required fields by enforcing presence.

3. Implement strict mode checks

In strict mode, after validating known fields, iterate over the JSON object's keys to ensure no unknown fields are present. Reject or report errors for any extra fields.

4. Handle edge cases and error reporting

Consider null values, arrays of nested types, and type mismatches. Decide whether to fail fast or collect all errors, and explain your choice.

5. Discuss trade-offs and optimizations

Talk about performance implications of recursion, potential for memoization, and trade-offs between strict and lenient validation. Mention extensibility for future schema features.

Key Points to Mention

Recursive traversal of schema and JSON document
Type checking (string, number, boolean, object, array, etc.)
Optional vs required field handling
Strict mode: rejecting unknown fields
Nested message types and arrays of nested types
Error aggregation vs fail-fast and trade-offs

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