Merge Software Engineer Interview Questions
4+ questions from real Merge Software Engineer interviews, reported by candidates.
Round Types
Top Topics
Questions
Backend System Design: Design a Scalable Backend for a Real-Time Collaborative Document Editor
## Round 1 - System Design ## Problem Design the backend for a real-time collaborative document editor (think Google Docs). Multiple users edit the same document simultaneously. Changes must appear on all clients within 500ms. The system must handle merge conflicts, offline editing with sync-on-reconnect, and document history (full undo). **Requirements:** - 1M concurrent documents, up to 50 simultaneous editors per document - Operations: insert, delete, format — all at character granularity - History: unlimited undo per user, full document version history ## Follow-ups 1. Walk through Operational Transformation (OT) vs. CRDTs — which would you choose and why? 2. How does your system handle a user who goes offline for 10 minutes and comes back with 200 buffered operations? 3. What is your persistence model — event sourcing, periodic snapshots, or both? 4. Describe the WebSocket session lifecycle: how do you handle reconnects and ensure no operations are lost or duplicated?
## Problem Build core operations for a browser-based paint editor using an HTML5 Canvas. Implement: freehand drawing (mouse drag), straight lines, flood-fill (paint bucket), and undo/redo with a 20-step history. ```typescript class PaintEditor { constructor(canvas: HTMLCanvasElement) {} setTool(tool: 'brush' | 'line' | 'fill'): void {} setColor(hex: string): void {} setBrushSize(px: number): void {} undo(): void {} redo(): void {} // Internal: called on mouse events private onMouseDown(e: MouseEvent): void {} private onMouseMove(e: MouseEvent): void {} private onMouseUp(e: MouseEvent): void {} } ``` **Example behavior:** ``` editor.setTool('fill'); editor.setColor('#FF0000'); // User clicks on a blue region -> flood-fill changes all connected blue pixels to red editor.undo(); // restores the blue region ``` ## Follow-ups 1. How does flood-fill work at the pixel level? What queue-based BFS approach do you use? 2. For undo/redo, do you store full canvas snapshots or operation deltas? What are the tradeoffs? 3. Freehand drawing at high mouse speed leaves gaps between points — how do you interpolate? 4. How would you add a selection tool with copy/paste and move operations?
## Problem Implement a pretty printer that takes a nested Python object (dicts, lists, primitives, custom objects) and renders it as formatted, indented text. It must handle: cycles (print `<circular ref>`), custom `__repr__` on objects, and a max-depth cutoff (print `...` beyond depth `d`). ```python def pretty_print(obj: Any, indent: int = 2, max_depth: int = 5) -> str: pass ``` **Example:** ``` data = {"users": [{"name": "Alice", "scores": [10, 20]}, {"name": "Bob"}], "count": 2} pretty_print(data, indent=2) ``` ``` { "users": [ { "name": "Alice", "scores": [10, 20] }, {"name": "Bob"} ], "count": 2 } ``` ## Follow-ups 1. How do you detect circular references — using `id()` and a seen set? 2. What is the time and space complexity of your traversal? 3. How would you add colorized terminal output (keys in blue, strings in green, numbers in yellow)? 4. Extend to support line-length limits — if a list fits on one line, keep it inline.
## Problem Simulate water flowing across a height matrix, determining which cells drain to each ocean or boundary. ## Likely LeetCode equivalent Related to LC 417 Pacific Atlantic Water Flow. ## Tags coding, matrix, graph, BFS, onsite
What Merge Looks for in Software Engineer Interviews
Merge Software Engineer interviews are calibrated against the level and scope expected of the role. Across 4+ verified candidate reports on LeakCode, the consistent signals interviewers look for: clear problem decomposition before coding, explicit complexity reasoning, structured handling of edge cases, and the ability to articulate trade-offs between two reasonable approaches.
The discriminator between candidates who advance and candidates who do not is rarely the final correctness of the solution. It is the path to the solution: did you ask clarifying questions, did you state your approach before coding, did you handle edge cases without prompting, and did you communicate your reasoning throughout. Reports tagged "no hire" frequently cite a working solution with poor communication; reports tagged "strong hire" cite clear thinking even when the final solution was incomplete.
How To Use This Question Set
Real interview reports are a calibration tool, not a memorization target. Companies update their question pools every 2-4 months; memorizing exact problems risks misleading you when the interviewer uses a variant. The high-leverage use: identify the patterns that appear repeatedly in Merge Software Engineer reports, practice those patterns on similar (not identical) problems, and use the reports to understand the interviewer's typical follow-up depth.
Filter the questions below by round type, difficulty, and recency. Focus first on reports from the past 6-12 months; older reports may reference questions that have since rotated out of Merge's pool. Reports tagged with quantified difficulty (e.g., "medium-hard") are higher-signal than reports without difficulty tags.
Round-by-Round Expectations
Merge Software Engineer loops typically span 4-6 rounds across phone screens and on-site or virtual on-site interviews. The structure varies by company: some run 1 recruiter screen + 1 technical phone + 3-4 on-site rounds; others run 1 recruiter screen + 1 OA + 4-5 on-site rounds. The recruiter screen is logistics and culture-light; the technical phone screen is medium-difficulty coding; the on-site loop covers coding, system design (at L4+ levels), and behavioral rounds.
Each round is designed to surface a specific signal. Coding rounds: correctness, code quality, complexity reasoning, communication. System design rounds: requirements clarification, design judgment, operational thinking. Behavioral rounds: ownership scope, leadership, ambiguity tolerance, conflict navigation. Strong candidates explicitly hit each signal dimension out loud during the round; weak candidates focus only on solving the prompt.
Common Interview Mistakes At This Combination
Reports tagged "no hire" at Merge Software Engineer commonly cite: jumping into code without clarifying requirements, coding silently for 10+ minutes without verbalizing approach, missing edge cases (empty input, single element, very large input, overflow), and producing a working solution that the candidate cannot explain or refactor when probed. Strong candidates avoid these patterns by following a consistent template: clarify, verbalize approach, code with narration, test with examples.
Behavioral and design rounds have their own failure modes. Behavioral: stories that use "we" instead of "I" diluting individual signal, stories with no quantified outcome, defensiveness when probed about failure. Design: not asking clarifying questions, not stating requirements out loud, designing for a single server when the prompt clearly implies scale, ignoring operational concerns (deployment, monitoring, rollback). These show up in roughly half of Merge Software Engineer interview retrospectives on LeakCode.
See All 4 Merge Software Engineer Questions
Full question text, answer context, and frequency data for subscribers.
Get Access