Anrok·Software Engineer·Technical Phone Screen·Senior

SeniorPrefer not to say

Jun 2026Remote

Summary

Anrok software engineering interview that was basically one big design question about batching async HTTP requests. Pretty involved for a single problem, they wanted the whole thing: data structures, edge cases, failure modes, complexity analysis. Left feeling like I covered maybe 70% of what they were looking for.

Questions Asked (1)

You have a backend endpoint GET /read?keys=k1,k2,... that returns a JSON map of key-value pairs. Given two primitives, httpGetAsync and parseKvs, implement a getKeyAsync(key, callback) interface that batches concurrent requests into a single HTTP call every 100ms, deduplicates keys, ensures callbacks are only resolved by the batch they arrived before, and supports multiple in-flight batches simultaneously. Also cover missing keys, partial failures, retries, cancellation, and complexity.

System DesignAPI & IntegrationsTechnical Trade-offs

Author's notes

This one sprawled.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the requirements and constraints, then design a batching mechanism with a queue and timer, ensuring deduplication and batch isolation. Walk through the implementation details, covering edge cases like missing keys, partial failures, retries, and cancellation, and analyze time/space complexity.

Pro tip: Emphasize that each batch is independent and callbacks are tied to the batch in which they arrived, preventing cross-batch resolution. Also, discuss how to handle retries without blocking subsequent batches and how to cancel pending callbacks if needed.

1. Clarify Requirements and Constraints

Ask questions to confirm assumptions: Are keys case-sensitive? What should happen if a key is missing? How many retries? Is cancellation per-key or global? This ensures alignment before diving into design.

2. Design the Batching Mechanism

Use a queue to collect keys and a timer to trigger a batch every 100ms. Deduplicate keys within the batch by using a map from key to list of callbacks. Ensure each batch is independent and callbacks are only resolved by their batch.

3. Implement the getKeyAsync Function

For each call, add the key and callback to the current batch. If no batch is active, start a timer. When the timer fires, send the HTTP request with the deduplicated keys, then resolve callbacks based on the response.

4. Handle Edge Cases and Failures

For missing keys, invoke callbacks with undefined or an error. For partial failures, retry failed keys with exponential backoff up to a limit. Support cancellation by removing callbacks from the batch or ignoring responses if cancelled.

5. Analyze Complexity and Trade-offs

Discuss time complexity: O(1) per getKeyAsync call, O(n) per batch where n is unique keys. Space complexity: O(m) for m pending callbacks. Mention trade-offs like batching delay vs. latency, and retry impact on throughput.

Key Points to Mention

Deduplication of keys within a batch to avoid redundant requests and callback duplication.
Batch isolation: callbacks are only resolved by the batch they were added to, preventing cross-batch resolution.
Handling missing keys: decide whether to return undefined, null, or an error, and ensure callbacks are invoked.
Partial failures: retry only failed keys with exponential backoff, and consider max retries and timeout.
Cancellation: allow callbacks to be cancelled before the batch resolves, and ensure they are not invoked.
Complexity analysis: O(1) per call, O(n) per batch, and memory usage for pending callbacks.

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