Fault-Tolerant HTTP JSON Clients
Asked of: Software Engineer
Last updated

What's being tested
These exercises test whether you can combine graph traversal with a production-quality HTTP JSON client: discover reachable URLs, avoid cycles, parse untrusted responses, and terminate correctly. The interviewer is probing more than BFS syntax; they want explicit reasoning about retries, timeouts, authentication, malformed data, and bounded resource usage. Ramp cares because backend code frequently depends on external services, where correctness includes handling partial failure without hanging, duplicating side effects, or silently returning the wrong result.
Core knowledge
-
Graph traversal models each URL as a node and each returned path as a directed edge. Use BFS for minimum-hop discovery, DFS for lower memory; with URLs and links, traversal is excluding network latency.
-
Maintain a visited set keyed by a canonical URL, not the raw response string. Normalize relative paths with
URL, resolve dot segments, and define whether query parameter ordering, fragments, redirects, and trailing slashes represent the same node. -
A standard BFS uses a queue plus
visitedinsertion at enqueue time. Marking only when dequeuing allows duplicate queue entries and can cause explosive work; worst-case memory is , plus response and queue storage. -
Classify failures into retryable and terminal categories. Retry transient
408,429, and usually5xxresponses, transport resets, and timeouts; do not blindly retry400,401,403, malformed URLs, or invalid JSON. -
Use exponential backoff with jitter, such as . Cap attempts and total elapsed time; jitter prevents many clients from retrying simultaneously after an outage.
-
Set both a connect timeout and a read/deadline timeout. A retry loop without a global deadline can exceed the caller’s latency budget; propagate cancellation so queued and in-flight requests stop when the search is no longer useful.
-
Treat JSON as untrusted input. Check the HTTP status, content type when relevant, parse errors, object shape, field types, missing fields, and maximum response size before using a
pathsarray or success message. -
Define termination semantics precisely: a response containing the required congrats marker is success, while an empty path list is a dead end. Decide whether success is recognized only in the body, in a URL, or through a structured field.
-
Preserve authentication and request context across calls, typically with an
Authorizationheader or token parameter. Never log tokens, and distinguish an expired credential from a retriable server failure. -
Apply bounded concurrency only when the problem permits it. Parallel requests reduce wall-clock latency but require a worker limit, cancellation after success, synchronized visited-state updates, and careful handling of rate limits; sequential BFS is simpler and preserves level order.
-
Make retries safe by considering idempotency. Repeating a
GETis normally safe, but a generic client must not assume every method is harmless; mutation requests need an idempotency key or an application-specific retry policy. -
Separate the transport layer from traversal logic: one function fetches, retries, validates, and returns a typed result; another owns BFS/DFS and termination. This makes malformed JSON, timeout, and graph-cycle tests deterministic and keeps policy decisions visible.
Worked example
For “Find the Exit of an HTTP URL Maze Despite Flaky 503s and Bad JSON,” I would first clarify the success predicate, maximum maze size, URL format, authentication requirements, retry budget, and whether concurrent requests are allowed. I would state that each endpoint is a graph node, its JSON paths are outgoing edges, and malformed or terminally failed nodes are treated as unavailable rather than fatal unless the contract says otherwise. My answer would have four pillars: canonical URL normalization and deduplication, BFS traversal, a bounded HTTP fetch helper with timeout and retry policy, and strict JSON validation with explicit success detection. I would mark URLs visited when enqueuing, so cycles and repeated links cannot create duplicate work. I would use capped exponential backoff with jitter for 503, while enforcing a per-request and overall deadline. The key tradeoff is sequential BFS versus bounded parallelism: sequential traversal is easier to reason about and respects level ordering, while limited concurrency improves latency but complicates cancellation and rate limiting. I would close by saying that, with more time, I would add metrics for attempts, status classes, queue depth, and terminal failures, plus tests using a fake transport for cycles, invalid JSON, and eventual recovery.
A second angle
“Find exit URL via BFS API calls” emphasizes operational resilience around slow 500 responses and timeouts rather than only malformed payloads. The same separation applies, but I would make deadline propagation, retry classification, and cancellation first-class parts of the fetch helper. I would also ask whether the expected answer must be the shortest-hop exit, because that determines whether BFS ordering and early termination are semantically required. If requests can run concurrently, bounded workers and synchronized deduplication become central design constraints.
Common pitfalls
Pitfall: A tempting analytical mistake is to retry every non-
200response or to retry malformed JSON indefinitely. Better reasoning classifies failures by recoverability, caps attempts and elapsed time, and treats invalid application data as a bounded node failure unless the contract explicitly permits recovery.
Pitfall: A communication mistake is jumping directly into queue pseudocode without clarifying what constitutes an exit, how relative URLs are resolved, or whether duplicate query variants are equivalent. State those assumptions in the first minute; otherwise an otherwise-correct implementation may solve a different problem.
Pitfall: A depth mistake is mentioning “use exponential backoff” without specifying jitter, a maximum, and a global deadline. Conversely, designing a full circuit breaker or distributed crawler when the task is a bounded client obscures the required answer; explain the minimal robust design first, then identify production extensions.
Connections
An interviewer may pivot to circuit breakers, rate limiting, structured concurrency, or observability for distributed clients. They may also ask about Retry-After, redirect handling, idempotency keys, connection pooling, or how to test nondeterministic retry behavior with fake clocks and transports.
Further reading
-
RFC 9110: HTTP Semantics — authoritative treatment of methods, status codes, redirects, and request semantics.
-
Google SRE Book: Handling Overload — practical discussion of retries, overload amplification, and defensive client behavior.
-
AWS Architecture Blog: Exponential Backoff and Jitter — clear comparison of backoff strategies and why jitter matters.
Practice questions
- Find the Exit of an HTTP URL Maze Despite Flaky 503s and Bad JSONRamp · Software Engineer · Technical Screen · medium
- Crawl an HTTP-served maze to its exit with 503 retries, dead ends and cyclesRamp · Software Engineer · Technical Screen · medium
- Find an Exit in a URL MazeRamp · Software Engineer · Technical Screen · medium
- Find final URL by crawling until “congrats”Ramp · Software Engineer · Technical Screen · hard
- Implement a React flag loader with typewriter effectRamp · Software Engineer · Online Assessment · medium
- Find exit URL via BFS API callsRamp · Software Engineer · Technical Screen · medium
Related concepts
- Fault-Tolerant Backend System DesignSystem Design
- Resilient APIs And External Dependency IntegrationSystem Design
- Resilient API Aggregation And Operational DebuggingSoftware Engineering Fundamentals
- Robust Networking, REST, And Concurrency ControlSystem Design
- Reliable API Integration And Distributed DesignSystem Design
- Reliable Distributed Systems And IdempotencySystem Design