valon·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jun 2026

Summary

Valon software engineer interview had me extending a basic in-memory database to support filtered selects. Pretty focused session, one meaty coding problem with a design discussion tacked on at the end.

Questions Asked (1)

You have a simple in-memory database that supports INSERT and basic SELECT. Extend SELECT to accept a filter argument that matches rows on one or more column-value equality conditions. Walk through your implementation and then discuss how you'd generalize to other operators and add indexing.

System DesignAlgorithms & Data StructuresTechnical Trade-offs

Author's notes

The equality filter part was fine, just iterate rows and check every predicate.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the current schema and SELECT API, then design a filter representation (e.g., a map of column to value) and implement row matching with a simple loop. After that, discuss generalizing to other operators via an expression tree and adding indexing (e.g., hash indexes for equality, B-trees for ranges) with trade-offs.

Pro tip: Mention that you'd first check if the filter can be pushed down to an index to avoid full scans, and that you'd keep the filter representation extensible from the start to avoid rewrites later.

1. Clarify requirements and constraints

Ask about the data model, expected query patterns, and performance goals to scope the solution appropriately.

2. Design filter representation and matching logic

Define a filter as a set of column-value equality conditions and implement a function that iterates rows and checks all conditions.

3. Generalize to other operators

Introduce an expression tree or predicate interface to support operators like >, <, !=, and logical AND/OR without changing the core execution loop.

4. Add indexing for performance

Propose hash indexes for equality and B-trees for range queries, and explain how the query planner can choose an index based on the filter.

5. Discuss trade-offs and next steps

Cover trade-offs like memory overhead, write amplification, and complexity, and suggest incremental improvements like composite indexes or query optimization.

Key Points to Mention

Filter representation: map of column to value for equality, extensible to expression trees for other operators.
Row matching: iterate over rows and check all conditions; short-circuit on first mismatch.
Indexing: hash index for equality, B-tree for ranges; composite indexes for multi-column filters.
Query planning: choose index based on filter selectivity and operator type; fallback to full scan.
Trade-offs: index maintenance cost on writes, memory usage, and complexity vs. performance gain.
Extensibility: design for future operators and index types without major refactoring.

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