How do I tell whether I am in an API design interview or a system design interview?

Look at the size of the noun in the prompt. One feature inside a product that already exists, refunds, comments, likes or follows, means API design: they want the endpoint contract, status codes and idempotency. A whole deployable service, a URL shortener, a notification service or a job scheduler, means system design: they want capacity numbers, storage, queues and a named bottleneck.

What gets you rejected in an API design round?

Drawing a deployment diagram instead of a contract. Listing eight CRUD endpoints with no error model, no auth scope and no versioning stance. Returning 200 on an operation that failed. Using a floating point number for money. The most common single failure is having no answer for the duplicate request: if the client retries, your design must say whether the customer is refunded twice.

Do I need to estimate QPS in an API design interview?

Usually no, and volunteering a capacity estimate in the first two minutes reads as answering a different question. Numbers matter only when they change the contract: a result set large enough to force cursor pagination instead of offset, a rate limit that needs a 429 and a Retry-After header, or work slow enough that the endpoint has to return a pending resource.

What is an idempotency key and why does it come up in every API design round?

A client-generated string sent in a header on a write request. The server stores it alongside a hash of the request body and the response it returned, commonly for about 24 hours. A repeat with the same key and the same body replays the stored response instead of doing the work twice. A repeat with the same key and a different body should fail rather than succeed quietly.

Can one interview be both an API design and a system design round?

Yes, and hybrids are common. A round often starts at the endpoint contract and then asks how it holds up at a hundred times the traffic, or starts at boxes and arrows and then asks what the actual request body looks like. Treat the pivot as an instruction rather than a trap: stop expanding the layer you are on and answer at the layer they just named.

How should I open an API design interview?

Name the resource and the operation in one sentence, then confirm the scope. For refunds that is: a refund is its own resource with its own id, created against a charge, because a charge can be refunded partially and more than once. Then ask who calls it, a first-party mobile client or third-party developers, because that decides your versioning and error verbosity.

API Design Interview vs System Design Interview: The Tells

Both rounds open with the word "design". The difference is the size of the noun after it. If the prompt names one capability inside a product that already exists, refunds, comments, likes, follows, you are in an API design round and the deliverable is a contract: resources, payloads, status codes, idempotency. If it names something you could deploy on its own, a URL shortener, a notification service, a job scheduler, you are in a system design round and the deliverable is a shape: rough numbers, stores, queues, one named bottleneck. Answer at the wrong layer and a good answer still scores badly, because the rubric has rows you never touched.

The two rubrics, side by side

Interviewers are usually filling in a form. These are the rows where the two forms diverge.

Rubric row	API design round	System design round
Unit of thought	The request. One resource, one operation, the exact bytes crossing the wire in both directions, including on failure.	The box and the arrow. Services, stores and queues, plus what happens when one of them is down.
Native vocabulary	Idempotency key, cursor versus offset pagination, PUT versus PATCH, 409 versus 422, ETag and If-Match, error envelope, additive versioning, Retry-After.	Read to write ratio, storage per year, shard key, hot partition, replication lag, cache invalidation, fanout on read versus write, backpressure, dead letter queue.
What earns points	Pinning down the awkward case exactly. What the caller sees on a duplicate submit, a partial failure, a slow downstream. Naming the status code and the body, not the intent.	A quantity, then a bottleneck, then a mitigation, then the cost of that mitigation said out loud. Tradeoffs where you name the side you gave up.
What gets you buried	Sketching Kafka and read replicas while your endpoint still returns 200 on a failed refund. Eight CRUD routes with no auth scope, no error model, no versioning stance. Money as a float.	Ten minutes on JSON field names. Never producing a single number. Naming a technology with no reason attached. Building for a scale nobody asked for.

Neither round is the senior one, whatever the folklore says. API design is the harder one to bluff, because nearly every claim is checkable against real HTTP semantics and there is nowhere to hide behind a diagram.

The 60-second tell

Read the scope of the thing you were asked to design. A feature is a contract question. A product is a topology question.

Prompt	Read it as	Because
"Design the refunds API"	API design	Refunds sit inside a payments system that already exists. Duplicate submits and partial amounts are the meat.
"Design comments on a post"	API design	Threading, ordering and pagination of a reply tree are contract decisions before they are storage decisions.
"Design likes"	API design, with a scale tail	The toggle, the count and the idempotent double-tap are contract work. Only a celebrity-post follow-up turns it into fanout.
"Design a URL shortener"	System design	The product is the service. Key generation, collisions and a read-heavy cache are the answer.
"Design a notification service"	System design	Queues, fanout, retries, deduplication, per-channel delivery. The API surface is three endpoints and nobody cares.
"Design a job scheduler"	System design	Leases, at-least-once execution, clock skew, and what happens when a worker dies mid-job.
"Design a rate limiter"	Genuinely either	A distributed counter problem and a response header contract at once. This is the prompt to ask about.

Three tie-breakers when the noun alone does not settle it:

The tool they handed you. A shared text document or code editor usually means they expect signatures typed out. A blank infinite canvas usually means boxes. A hint, not a rule.
The words around the verb. "Endpoint", "contract", "client", "SDK", "third-party" pull towards API design. "At scale", "millions of users", "throughput", "availability" pull towards system design.
Who is asking. Platform and infrastructure teams tend to run the topology round. Teams whose product is itself an API tend to run the contract round, because that is the artefact their customers touch.

If it is still ambiguous, spend one sentence on it: "would you like me to start at the endpoint contract, or at the deployment shape?" That question has never cost anyone points. Guessing wrong and finding out at minute twenty-five has.

A worked answer skeleton: design the refunds API

The shape of a strong first ten minutes on an API prompt. Notice how little of it is about servers.

Make the refund its own resource

Open with POST /v1/charges/{charge_id}/refunds returning a refund object with its own id, not PATCH /v1/charges/{id} carrying a refunded: true flag. Say why in one line: a charge can be refunded partially and more than once, each attempt fails independently, and webhooks and support tickets need something to point at. That sentence separates people who have shipped an API from people who have read about one.

Write the request body out loud

amount as an integer in minor units, optional, defaulting to the remaining refundable balance. reason as a closed enum, duplicate, fraudulent, requested_by_customer, because free text here becomes an analytics problem forever. metadata as an opaque map. Say "integer minor units" explicitly: floating point money is one of the few things that ends an API round on the spot.

Handle the duplicate request before they ask

An Idempotency-Key header, client-generated, scoped to the endpoint and the account. This is the highest-value minute in the round, so slow down and be specific about storage and expiry instead of saying the word and moving on. The rules below are what the interviewer is listening for.

Name the status codes and the error envelope

201 with the refund object. 422 with a stable machine-readable code such as amount_exceeds_refundable, plus a human message and a param naming the offending field. 404 rather than 403 for a charge in another account, so you do not confirm it exists. 429 with Retry-After. Clients branch on code and never on the prose, so those strings are public contract and cannot be renamed later.

Admit the operation is asynchronous

Settlement takes days, so the endpoint cannot honestly return succeeded. Give the resource a status of pending, succeeded or failed, return 201 with pending, and deliver completion by signed refund.updated webhook with at-least-once delivery, backed by polling GET /v1/refunds/{id}. Candidates who return a synchronous success get taken apart at exactly this point.

Close with listing, auth and versioning

GET /v1/charges/{id}/refunds with cursor pagination, because offset pagination skips and duplicates rows when new refunds land mid-scan. Authorisation scoped to the account owning the charge plus a separate refund permission, since reading a charge should not imply the right to move money. Versioning in one sentence: new fields are additive and optional, an existing field never changes meaning, breaking changes get a new version.

The idempotency detail, since it is the graded part

Store the key with a hash of the request body and the full response you returned, under a time to live. Roughly 24 hours is a common window, and any number is defensible if you say it is deliberate.
Same key, same body, inside the window: replay the stored response byte for byte. One refund, however many times the client retries.
Same key, different body: 409. Accepting it quietly means a retry with a changed amount refunds a different sum than the caller believes.
Same key, first request still in flight: 409 with a retryable code, so a racing double-submit does not create two ledger entries.
Say what the client does with each. Retry 429 and 5xx with exponential backoff and jitter, never retry a 422.

When the round changes lanes mid-way

The common hybrid is an API prompt that pivots at minute twenty-five: "fine, now it is a hundred times the traffic and the ledger writes are the bottleneck". Not a trick, just the second half of the rubric. Stop refining field names and move up a layer: double-entry ledger writes, the transactional outbox that keeps webhook delivery alive across a crash between the database commit and the publish, deduplication on the consumer because at-least-once means the same event arrives twice. It runs the other way too, and both pivots are lost the same way, by carrying on answering the previous question in more detail.

Where a copilot is the wrong tool for this round

API design is the round where live assistance helps least. The output is a document you type while the interviewer watches, often in a shared editor where your keystrokes land on their screen as you make them, so polished paragraphs arriving at typing speed are conspicuous in a way a spoken answer is not. And the round is graded on the follow-up: why a header and not a body field, what breaks if the key expires after an hour, what if two clients generate the same key. A contract you did not reason your way to collapses at the second question.

OfferPilot AI runs on Windows 10 and 11 only. No macOS, no Linux, no mobile, no browser extension. If your interview is on a Mac, none of this applies to you.
Capture exclusion covers screen sharing and screen recording, nothing else. The overlay is excluded from screen capture at the operating system level, so it is absent from Zoom, Teams, Meet, OBS and screenshots while staying visible on your own monitor. It does nothing about a webcam, a lockdown browser, eye tracking, a second-device camera, or someone in the room.
The rules of the round belong to the company. Some interviews explicitly permit documentation and AI assistance, some do not. Read the instructions and ask when they are ambiguous.
Preparation beats improvisation here. The idempotency answer, the error envelope and the pagination argument are close to identical in every API round you will sit. Worth knowing cold rather than reading off a screen.

Practise the tell, not just the answers

Take ten prompts and classify each in under a minute before designing anything, then check yourself against the scope rule: feature or product. That habit is worth more than another read of a system design book, because misclassification rather than ignorance is what sinks most of these rounds. The question banks are a reasonable source of prompts to sort, the company Q&A generator builds a bank for a specific company and role so the prompts match the team you are actually interviewing with, and Code Copilot covers the algorithm round that usually sits alongside these two. OfferPilot AI's free tier is 5 minutes a day with no card; paid plans start at $39 a month and meter listening time only.

API design interview vs system design interview: how to tell which round you are in