← Applied Intuition Interview InsightsSoftware Engineer

Applied Intuition·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
May 2026

Summary

Applied Intuition system design round for a software engineer role. One big open-ended question about designing a schema catalog service, and they basically handed you the mic and let you drive. The lack of guardrails was either freeing or terrifying depending on how you handle ambiguity.

Questions Asked (1)

Q1

Design a service that lets users search across a large collection of schema files (Avro, Protobuf, JSON Schema, SQL DDL, etc.) with queries like 'find all schemas with a field named user_id of type long' or 'find schemas referencing type Address'. Cover parsing and normalization, storage choices, query API design, keeping the catalog fresh as schemas change, and scaling to millions of schemas.

System DesignData ModelingTechnical Trade-offs
Author's notes

This one took me a second to even figure out where to start.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then walk through the end-to-end pipeline: parsing and normalizing schemas into a canonical model, storing them in a search-optimized index, exposing a flexible query API, and keeping the catalog fresh via change data capture. Emphasize trade-offs at each stage, especially around indexing strategies and scaling to millions of schemas.

Pro tip: Propose a two-tier storage design: a relational/document store for the raw schemas and a specialized search index (e.g., Elasticsearch or a custom inverted index) for fast field-level queries. This balances durability, query flexibility, and cost, and shows you understand real-world constraints.

1. Clarify requirements and scope

Ask about query patterns, latency/throughput needs, schema formats, update frequency, and consistency requirements. This ensures you design for the right priorities.

2. Design parsing and normalization

Explain how to parse each schema format into a common intermediate representation (e.g., a graph of types and fields) and normalize naming, types, and references. Mention handling nested types, unions, and versioning.

3. Choose storage and indexing strategy

Propose a dual-store approach: a primary store for raw schemas and a search index optimized for field-level queries. Discuss indexing fields, types, and references, and how to scale the index (sharding, replication).

4. Define the query API

Outline a query language or API that supports field-based and reference-based searches, with filters, pagination, and sorting. Consider GraphQL or a RESTful API with a DSL.

5. Ensure freshness and scalability

Describe a change data capture pipeline to update the index as schemas evolve, and discuss scaling to millions of schemas via partitioning, caching, and async processing.

Key Points to Mention

  • Canonical intermediate representation for schemas (e.g., a type graph) to unify Avro, Protobuf, JSON Schema, SQL DDL.
  • Inverted index on field names and types for fast lookups, plus a reference index for type dependencies.
  • Trade-offs between Elasticsearch and a custom index (e.g., cost, flexibility, operational complexity).
  • Change data capture (CDC) and event-driven updates to keep the catalog fresh with minimal latency.
  • Sharding and partitioning strategies to scale to millions of schemas, including hot/cold storage.
  • Query API design with support for complex predicates (e.g., field name + type + nested conditions) and pagination.

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