HarveyAI·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say

Apr 2026

Summary

Coding round at HarveyAI for a software engineer role. One question, pretty focused: build a connection pool with acquire and release, db.query was already mocked so you just had to get the pooling logic right.

Questions Asked (1)

Implement a database connection pool with acquire() and release() methods. db.query is pre-mocked; focus only on the pool management logic.

System DesignTechnical Trade-offsAPI & Integrations

Author's notes

Sounds straightforward until you actually think about concurrency.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements: pool size, blocking vs. non-blocking acquire, timeout behavior, and thread-safety. Then design a thread-safe pool using a blocking queue of connections, with acquire() taking a connection (blocking or timing out) and release() returning it, ensuring connections are validated and not leaked. Finally, discuss trade-offs like fairness, max pool size, and error handling.

Pro tip: Mention that you would wrap acquire/release in try/finally or context managers to guarantee release even on exceptions, and that you'd add metrics (e.g., wait time, pool utilization) for observability—this shows production maturity.

1. Clarify requirements and constraints

Ask about expected concurrency, max pool size, whether acquire should block or fail fast, timeout support, and if connections need validation or health checks.

2. Choose a thread-safe data structure

Use a blocking queue (e.g., LinkedBlockingQueue) to hold available connections, which naturally handles blocking acquire and thread-safe release.

3. Implement acquire() with timeout and error handling

acquire() polls or takes from the queue with an optional timeout; if no connection is available, either block, throw an exception, or create a new one up to max size.

4. Implement release() safely

release() returns the connection to the queue; ensure it's idempotent and handles invalid connections by discarding and possibly creating a replacement.

5. Discuss trade-offs and extensions

Cover fairness (FIFO vs. LIFO), dynamic sizing, connection validation, leak detection, and metrics; mention how you'd test with mocked db.query.

Key Points to Mention

Thread-safety: use concurrent data structures or locks to protect pool state.
Blocking vs. non-blocking acquire: support timeout to avoid indefinite waits.
Resource management: ensure release in finally blocks or context managers to prevent leaks.
Connection validation: check health before handing out, discard broken connections.
Pool sizing: max size, dynamic growth, and backpressure when exhausted.
Observability: metrics for wait time, active connections, and errors.

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