Interview prep
Cursor Software Engineer, Core Services Interview Questions
Cursor's Software Engineer, Core Services owns the shared services between product surfaces and the infrastructure layer: auth, webhooks and the backend systems behind agent workflows. The posting asks for experience running critical backend services, opinions on multi-step reliability, and care for clean service contracts. Its closing note puts two or three short technicals ahead of an onsite project.

On this page
What does a Cursor Core Services engineer do?
The posting places Core Services between the product surfaces and the infrastructure layer. The team owns the critical shared services in that gap, and the posting names three of them: auth, webhooks, and the backend systems that power agent workflows. You build the systems every product team depends on, and the posting wants them reliable, well-abstracted and ready for whatever comes next.
Because those services are shared, a Core Services failure can surface as some other team's incident. The seat suits someone who likes owning systems that people notice only when they break. It is a poor fit if you need your work to be visible in the product.
- Team
- Engineering, on Core Services.
- Locations
- San Francisco; New York.
- Employment
- Full-time.
- Shape
- Backend service owner: auth, webhooks, SCM integrations and the agent backend, across the full production lifecycle.
- Compensation
- No range published.
Each of the five example projects names a system to own rather than a task to finish:
- Owning authentication: designing and implementing a scalable auth architecture that secures one of the most widely used developer tools in the world.
- Powering the agent backend: owning the infrastructure behind Cursor's agent workflows, optimizing for end-to-end performance and reliability as agents become central to the developer experience.
- Building a webhook server: high-throughput event delivery with proper retry semantics, dead-letter queues and observability so external integrations just work.
- Hardening SCM integrations: resilient abstractions over source control providers so Cursor stays solid regardless of third-party conditions.
- Driving end-to-end agent reliability: partnering with the client and inference teams to improve the full path from user action to agent response.
This is covered hands-on in Cursor Software Engineer, Infrastructure Interview Prep — 7 short Units, free to read.
Rather do it than read about it? Run 11 interactive Cursor walkthroughs in a simulated editor. Free, no account needed.
Where does Core Services' ownership stop?
The posting lists what you own but not what you don't, so the edges have to come from the neighbors it names. You partner with the client and inference teams on end-to-end agent reliability, which suggests the client and the model-serving path sit with those teams. The seat covers what a product surface calls on its way to the infrastructure layer: identity, event delivery, source-control access and the agent backend.
- You own
- Auth architecture; the webhook server; abstractions over SCM providers; the infrastructure behind agent workflows.
- You partner on
- End-to-end agent reliability, with the client team on one side and the inference team on the other.
- Adjacent, not yours
- The client; model serving and routing; product features built on top of your services.
- Stated bar
- Clean abstractions, well-defined service contracts, and work that other engineers find easy to build on.
Read the contracts bullet closely, because it asks what you care about rather than what you have done. Valuing well-defined service contracts is easy to claim. What you can show is whether other teams built on your services without talking to you. If your last platform had a contract that other teams consumed without a meeting, lead with it.
The second fit bullet separates this posting from a generic backend one. It asks for work on agent products or infrastructure, and strong opinions on the reliability and performance of complex multi-step systems. An agent run chains model calls, tool executions, SCM operations and client round trips, and any of them can fail halfway. For a run like that, reliability means what happens to the work in progress when step six of nine times out.
SCM integrations should stay solid regardless of third-party conditions, and webhook delivery should just work for external integrations. Both projects assume the other side will be slow, rate-limited or down. Prepare to design for a provider that misbehaves.
What does the Core Services interview assess?
This posting describes a process. Its closing note says that candidates who appear to fit get "2-3 short technicals," followed by "an onsite in our office, where you'll work on a small project, discuss ideas, and meet the team." Nothing more is published: no stage content, take-home policy or language list.
Experience building and operating critical backend services, especially auth systems, API gateways or webhook infrastructure.
Work on agent products or infrastructure, and strong opinions on the reliability and performance of complex multi-step systems.
Care for clean abstractions and well-defined service contracts, strong engineering fundamentals, and enjoyment of owning the full lifecycle of production services.
A fifth bullet is marked as a plus: experience with authentication and authorization frameworks (OAuth, JWTs, RBACRole-Based Access Control. Granting permissions by role rather than configuring each person individually. Press Enter for the full definition.), event-driven architectures, or developer-facing platform services. We would treat the auth part as close to required, because owning authentication is the first example project. You don't need to have built an identity provider. You should be able to argue about token lifetimes and scope boundaries without looking them up.
Beyond the project, the discussion and meeting the team, the posting says nothing about the onsite, including what the project is. Prepare to build a small working service under time pressure in a language you know well, and re-read the posting before you assume a format.
What interview questions should I expect?
The rows below start from the posting's example projects and fit bullets. Each pairs a question you could face with what a strong answer does that a weak one doesn't. The questions are ours, not Cursor's.
- From the posting
- A scalable auth architecture for a widely used developer tool
- Expect to be asked to...
- Design auth for a desktop client, a web app, a CLI and a cloud agent that all act as the same user.
- Strong answer vs weak
- Strong: distinct token lifetimes and scopes per surface, with revocation. Weak: one long-lived API key.
- From the posting
- Webhook delivery with retry semantics, dead-letter queues, observability
- Expect to be asked to...
- Design delivery to a flaky external endpoint; say what you retry, when you stop, and how a customer finds a lost event.
- Strong answer vs weak
- Strong: idempotency keys, bounded backoff, a DLQ with a replay path. Weak: "retry three times."
- From the posting
- Resilient abstractions over source control providers
- Expect to be asked to...
- Put GitHub, GitLab and a self-hosted SCM behind one interface, then handle one of them rate-limiting you mid-operation.
- Strong answer vs weak
- Strong: names the operations that do not map cleanly and isolates them. Weak: a uniform wrapper that hides the differences.
- From the posting
- Infrastructure behind agent workflows, end-to-end reliability
- Expect to be asked to...
- Decide what happens to a nine-step agent run when step six times out, and what the user sees.
- Strong answer vs weak
- Strong: checkpointing, idempotent replay, a visible partial state. Weak: "restart the run."
- From the posting
- Partnering with client and inference teams on the full path
- Expect to be asked to...
- Trace a slow agent response across client, your services and inference, and say where you would instrument first.
- Strong answer vs weak
- Strong: a trace id that crosses all three and a first suspect. Weak: "add more logging."
- From the posting
- Service contracts other engineers build on
- Expect to be asked to...
- Describe a contract you published, how it was versioned, and how a breaking change shipped without breaking a consumer.
- Strong answer vs weak
- Strong: a real migration with a deprecation window. Weak: "we told them in Slack."
- From the posting
- Owning the full lifecycle of production services
- Expect to be asked to...
- Tell the story of a service you ran from design through an incident and what changed afterwards.
- Strong answer vs weak
- Strong: a structural fix with a measured result. Weak: a postmortem whose action items never shipped.
| From the posting | Expect to be asked to... | Strong answer vs weak |
|---|---|---|
| A scalable auth architecture for a widely used developer tool | Design auth for a desktop client, a web app, a CLI and a cloud agent that all act as the same user. | Strong: distinct token lifetimes and scopes per surface, with revocation. Weak: one long-lived API key. |
| Webhook delivery with retry semantics, dead-letter queues, observability | Design delivery to a flaky external endpoint; say what you retry, when you stop, and how a customer finds a lost event. | Strong: idempotency keys, bounded backoff, a DLQ with a replay path. Weak: "retry three times." |
| Resilient abstractions over source control providers | Put GitHub, GitLab and a self-hosted SCM behind one interface, then handle one of them rate-limiting you mid-operation. | Strong: names the operations that do not map cleanly and isolates them. Weak: a uniform wrapper that hides the differences. |
| Infrastructure behind agent workflows, end-to-end reliability | Decide what happens to a nine-step agent run when step six times out, and what the user sees. | Strong: checkpointing, idempotent replay, a visible partial state. Weak: "restart the run." |
| Partnering with client and inference teams on the full path | Trace a slow agent response across client, your services and inference, and say where you would instrument first. | Strong: a trace id that crosses all three and a first suspect. Weak: "add more logging." |
| Service contracts other engineers build on | Describe a contract you published, how it was versioned, and how a breaking change shipped without breaking a consumer. | Strong: a real migration with a deprecation window. Weak: "we told them in Slack." |
| Owning the full lifecycle of production services | Tell the story of a service you ran from design through an incident and what changed afterwards. | Strong: a structural fix with a measured result. Weak: a postmortem whose action items never shipped. |
Our questions, built from the five example projects and the fit list.
Answer from systems you have run. The posting's verbs are about owning and operating, and follow-up questions quickly expose a design you only read about.
How do I prepare for the Cursor Core Services interview?
Build a small webhook server properly. Of the five example projects, it is the one that fits in a weekend. Run against an external endpoint that misbehaves, it exercises most of what that project names: retry semantics, dead-letter queues and observability. Once you have run one, a question about delivery semantics becomes a story about a real bug you found.
- 1Build a webhook server that delivers to a deliberately flaky endpoint, with idempotency keys, bounded exponential backoff, a dead-letter queue and a replay command. Keep a list of the edge cases that surprised you.
- 2Sketch auth for four surfaces (desktop client, web, CLI and cloud agent) acting as one user. Decide token lifetimes, scopes, and how revocation reaches each surface.
- 3Write the SCM interface on paper. List the operations an agent needs (clone, branch, push, open and update a PR, read checks) and mark the ones where GitHub and GitLab disagree.
- 4Prepare an answer for step six of nine timing out. For a multi-step agent run, decide what state is checkpointed, what is safe to replay, and what the user sees while it recovers.
- 5Bring one full-lifecycle story: a service you designed, ran, broke and fixed, with the number that proved the fix.
The partnership project is easy to dismiss as process. Driving end-to-end agent reliability with the client and inference teams means you share responsibility for latency and failures that start in someone else's code. The practical skill is cross-team instrumentation: a trace that survives the hop from the client into your services and out to inference. Be ready to describe how you would put that trace in place and what you would measure first.
To see the hops in one Cursor product, read our page on cloud agent security and network. It covers which networks Cursor's cloud agents can reach and how they connect to private services.
Our practice catalog has no Core Services track. Its Software Engineer, Infrastructure track is the closest match, covering cloud networking, clusters, edge security and cost tradeoffs. Use it for backend depth, not for process: its mock rounds include stages that this posting doesn't describe.
Each day, pick one service boundary you know. Write down what happens there when the far side is slow, down or wrong, and what the contract promises the caller in each case. A week of these notes gives you the multi-step reliability opinions the posting asks for, written down before anyone asks.
Frequently asked questions
Does Cursor publish the interview process for the Core Services role?
Partly. Its closing note describes two steps for candidates who appear to fit: two to three short technicals, followed by an office onsite that includes a small project and time with the team. What happens inside each stage isn't published.
Is the Cursor Core Services role remote?
The posting lists San Francisco and New York, full-time in Engineering, and doesn't list Remote. Its last published stage is an onsite in the office, and it publishes no compensation range.
What systems does the Core Services team own?
Per the posting: authentication, the webhook server, abstractions over source control providers and the infrastructure behind Cursor's agent workflows. The team also partners with the client and inference teams on end-to-end agent reliability.
Is auth experience required?
Auth frameworks such as OAuth, JWTs and RBAC appear in a bullet marked as a plus. But owning authentication is the first example project, and auth systems appear in the first fit criterion, so treat auth as close to required. Be ready to reason about token lifetimes, scopes and revocation across several client surfaces.
Sources & last verified
Cursor ships frequently. Last updated October 28, 2026.