Harvey Software Engineer interview questions & guide 2026

Interviewing at Harvey involves practical, domain-relevant engineering problems. Rather than abstract algorithmic puzzles, the technical rounds assess your ability to build functional, clean, and extensible data structures under strict time constraints. Questions are drawn directly from real candidate interview experiences and reflect typical challenges faced by the engineering team.

Data Structures & Custom File Systems

This category tests your ability to design in-memory data structures, write clean APIs, and manage hierarchical or stateful data. Interviewers look for clean object-oriented design, proper handling of edge cases, and algorithmic complexity awareness.

• Spreadsheet Cell Engine: Implement an in-memory spreadsheet class with get_cell(A1) and set_cell(A1, value) functions. Extend the design to handle formulas, update dependent cells with $O(1)$ reads via precomputation, and detect cyclic dependencies using topological sort or DFS.
• Vault File System & Naming: Implement an in-memory file/directory system for Vault supporting create_file, create_folder, and list_files. Handle duplicate file uploads by appending sequential copy markers (e.g., turning duplicate file A into A_1 or A(1)).
• Text Editor Cursor Management: Design a cursor-based text editor capable of inserting text, deleting text, and moving a cursor back and forth while maintaining efficient time complexity (similar to LeetCode 2296).
• Duplicate Directory Scanner: Given helper methods list_dir(root) and is_dir(path), implement a function find_dups(root) that scans a filesystem iteratively (using BFS) and groups duplicate files by content.

Parsing, String Processing & Algorithmic Logic

These questions evaluate your fluency in text manipulation, interval tracking, and state management—critical capabilities for processing large-scale legal documentation.

• Source & Phrase Highlighting: Given a string paragraph and a list of matched search phrases, return the paragraph with the matched portions wrapped in XML tags (<highlight>phrase</highlight>). Extend this to handle overlapping matches, nested phrases, and sequential adjacent tags.
• Citation Parser: Build a multi-part citation parser that ingests legal text, extracts source citations, matches them against a source repository, and formats the output deterministically while tracking time and space complexity.
• Task Scheduling & Machine Allocation: Given an array of task start and end times, compute the minimum number of parallel compute machines required to execute all tasks without overlap.

AI Systems, RAG & Distributed Architecture

These system design scenarios evaluate your capability to architect secure, low-latency enterprise applications, high-throughput model proxies, and retrieval platforms.

• Review Table Backend Architecture: Design the backend architecture for Harvey’s Review Table product. Users submit prompts across large file collections stored in Vault, requiring scalable retrieval, parallelized LLM inference execution, and dynamic structured table formatting.
• Legal Document RAG & Memo Q&A: Architect a high-throughput Q&A system for legal memos. Address vector storage, document chunking strategies, hybrid search (keyword + semantic), context window management, and deterministic citation tracking.
• Google Drive / Vault File Storage: Design a secure, multi-tenant file storage and sharing platform. Detail the upload pipeline (handling upload pause/resume), file chunking, ACL access controls, and multi-region data residency.

Behavioral & Core Values

Behavioral questions assess how well you align with Harvey’s core Operating Principles: Simplicity, Decisiveness, and Job's Not Finished.

• Tell me about a time you had a major disagreement with a technical lead or manager regarding architecture. How did you resolve it?
• Describe a situation where you had to make a rapid technical decision with incomplete information or under extreme time pressure.
• How do you gather and act on harsh technical feedback from peers during code and design reviews?

Preparing for an interview at Harvey requires balancing practical coding proficiency with enterprise system design principles. Interviewers look for strong execution speed, crisp technical communication, and a focus on shipping production-grade solutions.

Role-Related Technical Depth – You must demonstrate mastery over foundational data structures, multi-threading, memory management, and backend system patterns. Whether writing an in-memory file system or designing a proxy for model endpoints, your solutions must account for edge cases, performance bottlenecks, and scale.

Practical Problem Solving – Harvey values practical, domain-adjacent problem solving over hyper-theoretical algorithms. You will be expected to read problem statements, break down multi-part requirements, write your own test cases, and execute working code live within tight timeframes.

Velocity & Execution Mindset – With a lean team and massive growth, engineering success at Harvey relies on decisiveness and autonomy. Candidates who ask clarifying questions quickly, propose minimal viable architectures, and focus on functional implementations stand out over those who over-engineer or get stuck in design paralysis.

Culture & Value Alignment – You must demonstrate a high degree of ownership and resilience. Harvey evaluates candidates against their internal ethos: maintaining simplicity in design, taking decisive action in ambiguous situations, and ensuring full execution ("Job's Not Finished").

The software engineering interview process at Harvey is fast-paced, highly technical, and practical. The process evaluates clean code implementation, system engineering fundamentals, and product execution.

The evaluation process typically starts with a initial recruiter call or technical online assessment, followed by a live technical phone screen. Successful candidates then move to the multi-round onsite loop, which can be conducted virtually or in-person at key engineering hubs like San Francisco or New York. The onsite contains hands-on live coding, system design, a project deep dive, and a values discussion.

The timeline module above maps out the typical progression from initial recruiter outreach to the final offer decision. Candidates should treat each stage as a distinct assessment point—the technical screen evaluates speed and execution, while the onsite rounds test broad architectural intuition, deep domain ownership, and alignment with company culture.

Candidates are evaluated across four primary technical pillars. Each area probes specific skills necessary to build reliable, high-throughput legal AI platforms.

       Coding & Data Structures (40%)
                 /   \
                /     \

Area 1: Coding & In-Memory Data Structures

This evaluation area tests your ability to translate ambiguous operational problems into structured, working code. Problems usually involve designing in-memory data structures with custom read/write constraints.

Be ready to go over:

• State Management & Caching Strategies – Designing data structures that balance read-heavy vs. write-heavy operations.
• Dependency & Graph Resolution – Implementing algorithms like topological sort or depth-first search to detect cyclic dependencies in cell spreadsheets or build systems.
• Hierarchical File Trees – Building custom tree/trie structures to model file paths, directory traversal, and dynamic file renaming algorithms.
• Advanced concepts (less common) – Spatial partitioning structures like R-trees, graph flow models (minimum cost flow), and custom memory-mapped cache structures.

Example scenarios:

• "Implement an in-memory spreadsheet supporting formulas, circular dependency detection via topological sort, and $O(1)$ read performance."
• "Code an in-memory file system that manages duplicate file path uploads by dynamically renaming files with version suffixes."

Area 2: System Design & AI Platform Architecture

The system design round evaluates your ability to design robust, fault-tolerant platforms. Depending on your target team, focus areas range from infrastructure pipelines (load balancing, multi-region residency, rate limiting) to LLM agent frameworks and RAG architectures.

Be ready to go over:

• RAG & Search Systems – Vector index architecture, document chunking, hybrid search indexing, dynamic context window assembly, and token budget management.
• Distributed Rates & Model Proxies – Implementing token bucket or Redis-backed rate limiters, fallback mechanisms, and multi-region API proxies for frontier models.
• Storage & Synchronization Pipelines – File ingestion engines for massive PDF datasets, chunked multi-part upload protocols, and fine-grained access control lists (ACLs).
• Advanced concepts (less common) – Distributed transaction management across cloud providers (Azure/GCP) and fine-grained observability infrastructure for token cost attribution.

Example scenarios:

• "Design the backend system for Review Table: query processing over thousands of uploaded legal documents in Vault with low latency."
• "Architect a distributed model proxy capable of routing millions of daily LLM inference requests with dynamic rate limiting and failover capabilities."

Area 3: Project Deep Dive

The project deep dive assesses your engineering maturity, technical leadership, and past ownership. You will present a complex technical initiative you personally owned from initial design to production deployment.

Be ready to go over:

• Architecture Decisions – Explaining trade-offs between speed, scalability, consistency, and simplicity in past projects.
• Technical Failures & Incident Response – Detailing production outages, root cause analyses, and structural post-incident improvements.
• Cross-Functional Collaboration – Articulating how you drove alignment with Product Managers, Security teams, and external users.
• Advanced concepts (less common) – Presenting pre-prepared technical architecture slides or RFC documentation detailing system design evolution.

Example scenarios:

• "Walk through the most complex system you designed from scratch. What were the core trade-offs, and what would you re-architect today?"
• "Describe a production failure in a platform you managed. How did you diagnose the issue under pressure, and how did you prevent recurrence?"

Area 4: Behavioral & Values Alignment

This interview probes your soft skills, work ethic, and operational habits against Harvey's primary core values: Simplicity, Decisiveness, and Job's Not Finished.

Be ready to go over:

• Feedback Loops – Giving and receiving critical code/architecture feedback without ego.
• Handling Ambiguity – Delivering production-ready code under shifting requirements or tight launch dates.
• Intensity & Speed – Balancing technical quality with aggressive delivery timelines.

Example scenarios:

• "Describe a scenario where you received blunt, critical feedback on a feature or pull request. How did you handle it?"
• "Tell me about a project where scope creep threatened the timeline. How did you simplify requirements to ship on time?"

A Software Engineer at Harvey wears multiple hats, operating with high autonomy across the full product and infrastructure lifecycle. Day-to-day responsibilities vary depending on team placement, but central activities include:

Building and Scaling Infrastructure Engineers on the Core Infrastructure and Platform teams build, scale, and optimize the multi-cloud infrastructure (primarily Azure and GCP) supporting Harvey’s enterprise applications. Responsibilities include building high-throughput model proxies, scaling Kubernetes clusters, implementing Redis-backed rate limiting, and building distributed observability tools to monitor latency, SLAs, and token attribution.

Developing Autonomous AI Agents and RAG Pipelines Engineers on the Agents and Product teams design systems that interact with frontier AI models. This involves developing evaluation harnesses (evals) to measure agent task quality, tuning prompt contexts, managing context windows, parallelizing tool execution, and building resilient retrieval mechanisms across millions of enterprise files.

Improving Developer Experience and Platform Engineering Engineers on the DevEx team build internal tooling, automated CI/CD pipelines (using Buildkite and GitHub Actions), custom test harnesses, and load-testing platforms. The goal is to maximize developer velocity, enabling engineering teams to ship safe, well-tested code multiple times a day.

Collaborating Across Disciplines Engineers partner directly with Product Managers, Legal Engineers, and security experts to understand legal workflows and translate them into technical specs. Teams operate with minimal overhead, placing high value on quick iteration, prototype validation, and post-launch refinement.

Harvey maintains a high bar for engineering talent. Qualifications focus heavily on practical system architecture, fast execution, and production engineering experience.

+-------------------------------------------------------------------+
|                     QUALIFICATIONS OVERVIEW                       |
+-------------------------------------------------------------------+
| Technical Core    : Python, Go, Cloud Systems (Azure/GCP/AWS)     |
| Architecture      : Kubernetes, Distributed Systems, Redis, IaC   |
| Domain Skills     : LLM Frameworks, RAG, Vector Search, Evals    |
| Soft Skills       : High Ownership, Decisiveness, Low Ego         |
+-------------------------------------------------------------------+

Must-Have Skills

• Strong Systems Fundamentals: 3+ years (Senior: 5–10+ years) of software engineering experience building production-grade backend systems or infrastructure.
• Language Proficiency: Expert-level knowledge of Python, Go, or similar systems programming languages.
• Cloud & Containerization: Experience with cloud environments (Azure, GCP, AWS), container management (Docker, Kubernetes), and Infrastructure-as-Code (Terraform, Pulumi).
• Execution Speed: Demonstrated ability to write clean, maintainable, and fully functioning code quickly, including self-written unit test coverage under timed conditions.

Nice-to-Have Skills

• AI/ML Infrastructure: Practical experience working with LLM APIs, prompt management, vector databases, agent frameworks, or custom evaluation harnesses.
• High-Throughput Systems: Background building distributed rate limiters, load balancers, caching systems, or high-volume API gateways.
• Developer Tools: Experience with CI/CD optimization, load testing platforms, and developer automation using AI tools.

Q: What is the primary coding language used during technical interviews? A: Candidates can generally choose any modern language for coding rounds, though Python and Go are strongly preferred given Harvey's internal tech stack and infrastructure needs.

Q: How difficult are the live coding rounds compared to standard LeetCode? A: Coding questions at Harvey lean toward practical, domain-adjacent data structure implementations rather than dynamic programming puzzles. Expect multi-part requirements (e.g., cell spreadsheet or in-memory file systems) where execution speed, clean API design, and functional code are strictly evaluated.

Q: Are candidates expected to write their own unit tests during coding interviews? A: Yes. Many interviewers do not provide pre-written test suites. You will be expected to construct and execute your own test cases to prove your code's correctness and edge-case handling.

Q: What is the work model and location expectation for engineering roles at Harvey? A: Harvey operates primarily on an in-person work model out of key offices, including San Francisco and New York, with relocation assistance provided for new hires.

Q: Does Harvey assess AI and RAG knowledge for non-AI engineering roles? A: Yes. Because Harvey is an AI-native company, core backend and system design interviews frequently incorporate LLM model proxies, token streaming, context window constraints, and RAG architectures regardless of the specific sub-team.

• Focus on Code Functionality First: During live coding rounds, aim for a working solution early. Interviewers value a fully working, clean implementation of parts 1 and 2 over a partially finished, complex architecture intended to solve part 3.
• Master Basic Data Structures for In-Memory Systems: Revisit trees, tries, hash maps, heaps, and graph algorithms (especially topological sort and BFS). In-memory file directories and spreadsheet dependency engines appear frequently in live rounds.
• Prepare Your Project Deep Dive Deck: Prepare a detailed, end-to-end breakdown of a complex project you owned. Be ready to discuss architecture diagrams, trade-offs, scaling limits, failure modes, and metrics.
• Clarify System Design Constraints Early: In system design rounds, immediately establish constraints regarding data volume, request throughput, file types (e.g., standard PDFs vs. unstructured formats), and read/write ratios.

Joining Harvey as a Software Engineer offers an exciting opportunity to build foundational technologies shaping the future of knowledge work. The engineering team solves high-impact problems across multi-cloud distributed systems, AI agent orchestration, vector retrieval, and enterprise security platforms.

To prepare effectively, focus on:

• Writing clean, modular in-memory data structures quickly under live coding conditions.
• Practicing multi-part problem scenarios like file trees, spreadsheet dependencies, and text/citation parsing.
• Studying end-to-end RAG pipelines, distributed model proxy architectures, and rate-limiting patterns for system design.
• Preparing behavioral examples that demonstrate high ownership, decisive decision-making, and technical leadership.

The compensation data above reflects current market ranges across engineering levels and locations. Offers at Harvey typically combine base salary with competitive equity packages reflecting the company's hyper-growth trajectory.

For additional interview insights, question sets, and practice materials to help you prepare, visit Dataford. Good luck with your preparation!