Ramp·Software Engineer·Technical Phone Screen·Intermediate

Intermediate

Jun 2026

Summary

Ramp software engineering interview with a graph traversal coding problem that had a few real-world constraints layered on top. The problem looked like a standard BFS/DFS at first glance but the HTTP retry and timeout requirements made it more involved than I expected.

Questions Asked (1)

Implement a web crawler starting from a root path that uses BFS or DFS to send HTTP GET requests and follow links returned in JSON responses until reaching an exit page. Your solution needs to handle cycles, retry on server errors, and respect timeouts while still guaranteeing completion if a valid path exists.

Algorithms & Data StructuresSystem DesignAPI & Integrations

Author's notes

The cycle detection part was easy enough, just keep a visited set.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the problem constraints and defining the crawler's behavior, then outline a BFS-based solution with a visited set to handle cycles, retry logic with exponential backoff for server errors, and configurable timeouts. Discuss how to guarantee completion by ensuring all reachable pages are explored until the exit page is found or the queue is exhausted.

Pro tip: Mention that you would use a concurrent BFS with a thread pool to parallelize requests while maintaining a shared visited set with proper synchronization, and discuss how to handle rate limiting and politeness policies to avoid overwhelming the server.

1. Clarify requirements and constraints

Ask about the expected scale, whether the crawler should be single-threaded or concurrent, and any specific retry/timeout policies. Confirm the definition of 'exit page' and how links are represented in JSON responses.

2. Design the core algorithm

Choose BFS for shortest path guarantee or DFS for memory efficiency. Use a queue (BFS) or stack (DFS) and a visited set to avoid cycles. Explain how you'll parse JSON responses to extract links.

3. Handle errors and timeouts

Implement retry logic with exponential backoff for server errors (5xx) and network failures. Set a timeout for each HTTP request and handle timeout exceptions by retrying or skipping after max attempts.

4. Ensure completion and termination

Guarantee that if a valid path exists, the crawler will find it by exploring all reachable pages. Use the visited set to prevent infinite loops and terminate when the exit page is found or the queue/stack is empty.

5. Discuss optimizations and scalability

Mention concurrent crawling with a thread pool, rate limiting, and distributed crawling if needed. Discuss how to handle large graphs and memory constraints.

Key Points to Mention

BFS vs DFS trade-offs: BFS guarantees shortest path but uses more memory; DFS uses less memory but may not find shortest path.
Cycle detection using a visited set (or hash set) to avoid infinite loops.
Retry mechanism with exponential backoff and jitter for transient errors (e.g., 5xx, timeouts).
Timeout handling: set connect and read timeouts, and treat timeouts as retryable errors.
Concurrency: use a thread pool or async I/O to parallelize requests while ensuring thread-safe access to the visited set.
Politeness: respect robots.txt, rate limiting, and avoid overwhelming the server.

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