Cursor Interview Questions & Experiences

Cursor·Backend Engineer·Onsite - System Design / Architecture

Jul 2026

System design round at Cursor for a backend role. The whole thing was basically one big question about rate limiting across a user/team/company hierarchy, then a bunch of follow-ups that went pretty deep into distributed systems territory. Left feeling okay about the core design but less confident on some of the edge cases they pushed on.

Design a production-grade rate limiter for notification sending that enforces per-user, per-team, and per-company limits simultaneously within an exact rolling 10-minute window. A send is only accepted if all three limits pass, and a rejection must not count against any scope.
How do you keep the user, team, and company rate limit checks atomic across concurrent requests from many stateless servers?
What clarifying questions would you ask before designing this system?
How do you handle the user-to-team-to-company mapping, and what happens when a user is transferred to a different team mid-operation?
If the limits were changed from 3/10/20 to thousands per window, would you still use an exact sliding window log, and what would you switch to if not?
One large company's traffic is making its shard a bottleneck. How do you relieve the hot shard while still enforcing the exact company-level limit?
Walk through what happens end-to-end when the Redis cluster is briefly unavailable. What does your service return, what gets logged, and how do counts reconcile when it comes back?
How would you add a fourth rate limiting scope, like a per-notification-channel limit, without rewriting the atomic core of the system?

“This was the core question and it ate most of the session.”

View Post

Cursor·Software Engineer·Technical Phone Screen

Jun 2026

Cursor software engineering interview that threw a streaming parser problem at me. The core task was building something that could handle incremental text input and correctly identify inline code spans versus fenced code blocks, even when the delimiters get split across chunk boundaries. Pretty niche problem and I wasn't fully prepared for how stateful the solution needed to be.

Build a streaming Markdown parser that handles inline code spans (single backtick) and fenced code blocks (triple backtick), where input arrives in arbitrary chunk sizes and delimiters can be split across chunk boundaries.
Should unterminated code spans at the end of the stream be emitted as plain text or held in a buffer indefinitely?
How would you extend the parser to support tilde characters as an alternate fence marker?
How would you prevent the parser from buffering an unbounded amount of text while waiting for a closing delimiter?
How would you make the parser resumable if the process restarts mid-stream?

“This one hurt a little.”

View Post

Cursor·Software Engineer·Technical Phone Screen

Jun 2026

Cursor SE interview had me implementing a Merkle tree from scratch, which sounds manageable until you're actually doing it under pressure. Pretty technical round, no fluff.

Implement a Merkle tree from a list of data blocks, supporting root hash exposure, inclusion proof generation, and proof verification without the full tree. Also discuss time complexity and real-world applications.

“This was the whole interview basically.”

View Post

Cursor·Software Engineer·Onsite - System Design / Architecture

Jun 2026

System design round at Cursor for a software engineer role. The whole session was basically one big deep dive into building a transactional key-value store from scratch, with a lot of follow-up pressure on concurrency edge cases.

Design an in-memory key-value database that supports transactional reads and writes, exposing begin, get, set, commit, and rollback operations.
How does your design handle two transactions that concurrently write to the same key?
How would you handle a read-write race where two transactions read stale values and then swap those values between two keys?
What isolation level should transactions provide, and what are the trade-offs between serializable isolation, snapshot isolation, and weaker guarantees?
How would you support reads outside of any transaction context?
How would you prevent long-running transactions from making commit validation increasingly expensive over time?
How would you write a test to reliably reproduce the two-key swap race condition?
What changes would be needed to make this database durable?

“I started with a simple map and a per-transaction write buffer, which felt right, but I underestimated how quickly the interviewer would push on isolation.”

View Post

Cursor·Software Engineer·Onsite - Coding / Algorithms

Jun 2026

Interviewed for a SWE role at Cursor and got asked to build a hash tree algorithm. Pretty sparse on details but it was clearly a technical coding round.

Implement a hash tree (Merkle tree) algorithm from scratch.

“Not something I'd drilled recently.”

View Post

Cursor·Software Engineer·Recruiter / HR Screen

May 2026

Applied for a SWE role at Cursor and got asked the classic motivation question. Not much else to go on here.

Why do you want to work at Cursor?

“Pretty standard opener but I fumbled it a bit.”

View Post

Cursor·Software Engineer·Technical Phone Screen

May 2026

Cursor SWE interview that was basically an OOD exercise disguised as a systems question. You build an in-memory key-value store with transactions, then they start layering on concurrency problems until things get uncomfortable.

Design and implement an in-memory transactional key-value database. Your class should support beginning a transaction, getting and setting values within a transaction, and committing or rolling back.
Two transactions try to write to the same key at the same time. How do you handle that write-write conflict?
Consider two transactions doing a swap: tx1 reads key A and writes it to key B, tx2 reads key B and writes it to key A. If both commit, the swap is a no-op. How do you detect and abort one of them?

“The skeleton they gave was pretty clean so I didn't waste time on structure.”

View Post

Cursor·Software Engineer·Technical Phone Screen

May 2026

Cursor SWE interview with a meaty coding problem around rate limiting. The core task was implementing a sliding window notification gate across three hierarchy levels simultaneously, plus writing and manually tracing through your own test cases.

Implement a function `should_send_notifications(user_id, timestamp)` that returns true or false based on a hierarchy of rolling-window rate limits: at most 3 per user, 10 per team, and 20 per company, all within a 10-minute window. The user-to-team-to-company mapping is provided. If the notification is allowed, record it and return true; otherwise return false. Also write real test cases and trace through them by hand.

“The per-entity sliding window part clicked pretty fast for me, keep a list of timestamps per user/team/company and prune anything older than 10 minutes on each call.”

View Post

Cursor·Software Engineer·Onsite - System Design / Architecture

May 2026

System design round at Cursor for a software engineer role. The whole thing was basically one big question that kept expanding, starting from a rate limiter and then getting pushed into distributed systems territory fast.

Design a distributed rate-limiting system that supports hierarchical scopes (user, team, company), including the API surface, storage layer, and how it behaves across multiple service nodes.
Compare sliding window counters, token buckets, and leaky buckets for rate limiting. What are the tradeoffs and which would you pick here?
How do you handle Redis outages in a rate limiter? Walk through the tradeoffs of different failure strategies.
How would you scale this rate limiter to millions of users while keeping p99 latency under 5ms?

“Started with the API and felt okay there.”

View Post

Cursor·Software Engineer·Technical Phone Screen

May 2026

Cursor SWE interview that was heavier on systems thinking than I expected. The main problem sounds deceptively like a data structures exercise but it really tests whether you can reason about real filesystems and design around actual constraints.

Implement a Merkle tree that mirrors a real directory structure on disk, where each directory is an internal node and each file is a leaf. You can only use standard library functions to read files and compute hashes.
Given two snapshots of the same repository, produce a diff showing which files were added, modified, or removed.
How would you efficiently handle large directories to avoid rehashing unchanged subtrees when comparing two snapshots?
How would you handle edge cases like symlinks, empty directories, and binary files in your implementation?

“The textbook Merkle tree is always binary, so my first instinct was to go that route.”

View Post