Quick answer: What API design and integration skills do developer jobs test?
- Designing APIs — resources and methods, status codes, error format, pagination, versioning.
- Securing APIs — OAuth 2.0, scopes, tokens, authorisation on every object.
- Reliability — idempotency keys, retries with backoff, timeouts, rate limits.
- Integrating — webhooks with signature checks, sandbox testing, clear documentation (OpenAPI).
- Who needs it — back-end, full-stack, integration, solutions and platform engineers.
Key takeaways
- Good APIs are predictable: consistent naming, errors and pagination matter more than cleverness.
- Idempotency and retries are where real-world integrations fail most.
- Broken object-level authorisation is the top API security risk — design checks in.
- Webhooks need verification, idempotent handling and replay tolerance.
- API design is a strong lever into senior back-end and solutions roles.
Picture an integration between a Mumbai e-commerce site and a payment gateway. The checkout calls "create payment", the network hiccups, and the client retries. Without an idempotency key the customer is charged twice. Later the gateway sends a "payment captured" webhook twice, and the order ships twice. Separately, a partner discovers that changing an order ID in the URL shows someone else's order. Three classic API failures — none of them about syntax. API design interviews test whether you'd have prevented all three.

Why API skills matter in hiring
APIs connect almost everything: mobile apps to back ends, services to each other, companies to payment gateways, messaging providers, logistics partners and AI models. That makes API design and integration a core skill for back-end, full-stack, integration, solutions and platform engineers — and a frequent topic in system design rounds.
These skills sit in well-paid roles. AmbitionBox shows typical back-end developer pay in India of ₹10.6–11.7 lakh in October 2026,7 and senior API and integration work leads to solutions architect and platform roles.
- Typical back-end developer pay in India (AmbitionBox, Oct 2026)
- ₹10.6–11.7 lakh
- Broken object-level authorisation's rank in OWASP's API Security Top 10
- #1
- The standard defining HTTP methods and status codes
- RFC 9110
- The common format for describing REST APIs
- OpenAPI
How API skills are tested
| Format | Example | What they check |
|---|---|---|
| Design exercise | "Design the API for a ride-booking app." | Resources, methods, errors, pagination |
| Concept questions | Status codes, idempotency, versioning | Understanding of HTTP and contracts |
| Security questions | "How do you stop users seeing others' orders?" | Authorisation, OWASP API risks |
| Integration scenario | "The payment provider times out. Now what?" | Retries, idempotency, webhooks |
| Code review | Critique an existing endpoint | Consistency and edge cases |
Table: How API design and integration are tested (editorial summary)
What good API design covers

Resources and methods
Nouns for resources, HTTP methods for actions, with semantics as defined in RFC 9110.1
Errors and status codes
Correct codes and one consistent error body with a machine-readable code and a human message.
Collections
Pagination (cursor-based for large or changing data), filtering, sorting and sparse fields.
Versioning and evolution
Additive changes, deprecation notices and a migration path; style guides like Microsoft's REST API Guidelines help.6
Security
OAuth 2.0 and scopes,3 object-level authorisation on every request and protections from the OWASP API Security Top 10.4
Contracts and docs
OpenAPI specifications,2 examples and changelogs.
Integration patterns that prevent incidents

Idempotency keys
Clients send a unique key with writes; the server returns the original result for repeats — the approach payment APIs such as Stripe document.5
Retries with backoff
Retry only safe or idempotent operations, with exponential backoff and jitter, and a cap.
Timeouts and circuit breakers
Never wait forever on a dependency; stop calling it when it's failing.
Webhooks
Verify signatures, respond fast, process asynchronously, deduplicate and tolerate out-of-order events.
Rate limits
Respect 429s and Retry-After; queue and smooth bursts.
Sandbox first
Test against providers' sandboxes and record real request/response examples.
Worked example: an order API, sketched
| Endpoint | Purpose | Notes |
|---|---|---|
| POST /v1/orders | Create an order | Requires Idempotency-Key header; returns 201 with the order |
| GET /v1/orders?cursor=…&limit=20 | List the caller's orders | Cursor pagination; only the caller's orders |
| GET /v1/orders/{id} | Fetch one order | 404 if not found or not the caller's (avoid leaking existence) |
| POST /v1/orders/{id}/cancel | Cancel | 409 if already shipped |
| POST /webhooks/payments | Receive payment events | Verify signature; dedupe by event ID; enqueue |
Table: A sketched order API with the design decisions interviewers look for (illustrative)
Talk through the choices: versioned path, idempotent creation, cursor pagination, ownership checks on every object, a cancel action modelled as a sub-resource with a clear conflict status, and a webhook endpoint designed for duplicates.
API interview questions, with how to answer them
"PUT vs PATCH?"
PUT replaces the whole resource (idempotent); PATCH applies a partial update.
"401 vs 403?"
401: not authenticated (no or invalid credentials). 403: authenticated but not allowed.
"Offset or cursor pagination?"
Offset is simple but slow and inconsistent on large, changing data; cursors are stable and efficient for feeds and big tables.
"How do you design error responses?"
Correct status code plus a consistent body: error code, message, details for field errors, and a request ID for support.
"How do you make a POST safe to retry?"
Idempotency keys stored with the result for a period; repeated requests return the stored result.
"REST, GraphQL or gRPC?"
REST for public, cacheable resource APIs; GraphQL when clients need flexible queries across related data; gRPC for fast internal service-to-service calls.
"How do you protect an API from abuse?"
Authentication, authorisation per object, input validation, rate limiting, quotas and monitoring.
"A partner's webhook arrives twice. What happens?"
Nothing bad, if you deduplicate by event ID and make processing idempotent.
How API expectations have changed
| Period | What happened | What employers expected |
|---|---|---|
| 2005–2010 | SOAP and XML web services | WSDL and enterprise integration |
| 2011–2016 | REST and JSON dominate; public APIs grow | RESTful design |
| 2017–2021 | OpenAPI, API-first companies, GraphQL | Contracts, documentation, developer experience |
| 2022–2024 | API security incidents rise | OWASP API risks, authorisation design |
| 2025–2027 | AI agents call APIs; MCP-style tool interfaces | Machine-readable, well-documented, safe APIs |
Table: How API expectations have changed (editorial summary)
Could you pass the API Design and Integration Certification today?
Hiring managers test judgement with scenarios like this one. Answer it before you open the explanation — the test has 15 of them, 15 minutes, 70% to pass.
Which status code means a resource was not found?
- 404
- 401
- 200
- 503
Show the answer
A. 404 — 404 Not Found.
- 01Designing APIs
- 02Integrating APIs
- 03API security and performance
Free, no sign-up. Pass and you become a API Design and Integration, with a credential ID employers can verify. Every answer is explained either way.
Practice tasks that build API skill
- Design on paper — Write an OpenAPI spec for a small library or booking system.
- Integrate a sandbox — Use a payment or messaging provider's sandbox with idempotency and webhooks.
- Break your own API — Try accessing another user's resource; fix object-level authorisation.
- Retry correctly — Add backoff with jitter and a circuit breaker around a flaky dependency.
- Write the changelog — Make a breaking change safely with a new version and deprecation notice.
Where API skills take your career
| Role (India) | Typical pay | API work |
|---|---|---|
| Back-end developer | ₹10.6–11.7 lakh | Designing and building APIs |
| Full-stack developer | ₹9.2–10.2 lakh | Building and consuming APIs |
| Software engineer | ₹9.3–10.2 lakh | Integrations across services |
| Software architect | ₹32.1–35.5 lakh | API strategy and platform design |

Table: Roles built on API skills and typical pay in India (AmbitionBox, October 2026; indicative)
A four-week plan

- Week 1: HTTP and REST — Methods, status codes, caching headers; read key parts of RFC 9110.
- Week 2: Design — Write an OpenAPI spec with errors, pagination and versioning.
- Week 3: Security and integration — OAuth flows, object-level authorisation, a sandbox integration with webhooks.
- Week 4: Prove it — Take the API Design and Integration Certification.
Related tests: REST API Testing, GraphQL Fundamentals and Back-End Development. See our back-end developer guide for the wider role.
How API work shows up day to day
- Design reviews — agreeing resources, errors and pagination with consumers before building.
- Integrations — connecting to payment, SMS, logistics or CRM providers through their APIs and webhooks.
- Incident handling — diagnosing failures caused by timeouts, rate limits or partner changes.
- Documentation — keeping OpenAPI specs and examples accurate.
- Versioning — planning deprecations with partners and mobile app release cycles.
- Security reviews — checking authorisation and data exposure on new endpoints.
More questions interviewers ask
"How do you document an API well?"
An OpenAPI spec kept in sync with code, examples for every endpoint, error catalogues, authentication guides and a changelog.
"What's the difference between authentication and authorisation?"
Authentication proves who the caller is; authorisation decides what that caller may do with each resource.
Mistakes that cost candidates
- Verbs in URLs and inconsistent naming.
- 200 OK for errors.
- No authorisation per object.
- Retrying non-idempotent calls.
- Undocumented breaking changes.
How we know
Technical references are IETF RFC 9110 and RFC 6749, the OpenAPI Specification, OWASP's API Security Top 10, Stripe's idempotency documentation and Microsoft's REST API Guidelines; pay from AmbitionBox (read October 2026). Test formats and the history table are editorial summaries. Science of Apps publishes the free certification linked here. Last reviewed October 2026.
Key terms, defined
- REST — an architectural style using resources and HTTP methods.
- Idempotency key — a client-supplied ID that makes retried writes safe.
- Pagination — splitting large results into pages.
- OAuth 2.0 — a framework for delegated, scoped access with tokens.
- Webhook — an HTTP callback sent when an event happens.
- OpenAPI — a standard format for describing HTTP APIs.
Frequently asked questions
What makes a good REST API?
Clear resource names, correct use of HTTP methods and status codes, a consistent error format, predictable pagination and filtering, versioning that doesn't break clients, authentication and authorisation on every request, and accurate documentation, usually in OpenAPI format.
Which HTTP status codes should I know?
200 OK, 201 Created, 204 No Content, 400 Bad Request, 401 Unauthorized (not authenticated), 403 Forbidden (not allowed), 404 Not Found, 409 Conflict, 422 Unprocessable Content, 429 Too Many Requests, 500 Internal Server Error and 503 Service Unavailable.
What is idempotency in APIs?
An idempotent operation has the same effect whether it's performed once or many times. GET, PUT and DELETE are idempotent by definition; POST isn't, so APIs that create payments or orders accept an idempotency key so clients can safely retry after timeouts.
How should I version an API?
Common approaches are a version in the URL path, a header or a media type. Whatever you choose, avoid breaking changes within a version, add fields rather than removing them, and give clients notice and a migration path before retiring old versions.
What is OAuth 2.0?
OAuth 2.0 is a framework for delegated authorisation: it lets an application get limited access to a user's resources on another service via access tokens and scopes, without handling the user's password. OpenID Connect adds identity on top for sign-in.
What are webhooks and how do you handle them safely?
Webhooks are HTTP callbacks a service sends to your endpoint when events happen, such as a successful payment. Verify the signature, respond quickly, process asynchronously, handle duplicates idempotently and be ready for events arriving out of order.
Sources
- IETF — RFC 9110, HTTP Semantics
- OpenAPI Initiative — OpenAPI Specification
- IETF — RFC 6749, The OAuth 2.0 Authorization Framework
- OWASP — API Security Top 10
- Stripe — Idempotent requests (API reference)
- Microsoft — REST API Guidelines (GitHub)
- AmbitionBox — Backend Developer salaries in India (updated 25 Oct 2026)
- Checked October 28, 2026. Figures that change — fees, salaries, prices — are reviewed every six months; if something is out of date, tell us.
Certifications to take next
- 20 AI skills for software engineers — copy-paste prompts for this job, one tap into ChatGPT or Claude
- API Design and Integration Certification — the free 15-minute test on designing, integrating and securing APIs
- What is an API? — the plain-English introduction
- Payment gateway integration — a real-world integration example
- Free skill test · 15 minREST API Testing CertificationTests how to test REST APIs — functional and negative tests, status codes, schema and contract testing, authentication, data setup, automation in CI and API security checks.
- Free skill test · 15 minAPI Documentation CertificationTests API documentation skills — writing reference docs with the OpenAPI Specification, creating quickstarts, tutorials and guides that improve developer experience, and docs-as-code workflows, style, versioning and maintenance.
- Free skill test · 15 minGraphQL Fundamentals CertificationTests GraphQL — schemas and types, queries, mutations and subscriptions, resolvers, the N+1 problem and DataLoader, pagination, errors and securing GraphQL APIs.
- Free skill test · 15 minBack-End Development CertificationTests server-side fundamentals — HTTP and REST, databases and transactions, authentication, caching, queues, scalability, logging and secure back-end design.
- Free skill test · 15 minSecure Coding Fundamentals CertificationTests secure coding against the OWASP Top 10 — injection, XSS, broken access control, authentication, secrets, dependencies, input validation and secure defaults.
- Free skill test · 15 minNode.js Development CertificationTests Node.js — the event loop, async patterns, modules, npm and package security, building HTTP APIs, streams, error handling and running Node in production.
Career guides for related roles
- Career guidesHow to get a back-end developer job in 2027: APIs, databases and the design round that decides itHow to get a back-end developer job in 2027: the API, database, security and system-design skills employers test, the interview loop, pay in India and a plan.
- Career guidesGraphQL interview questions and jobs in 2027: schemas, resolvers, N+1 and the production concerns employers testGraphQL interview questions and jobs in 2027: schema design, queries and mutations, resolvers and N+1, pagination, security limits and federation, with answers.
- Career guidesHow to get a Node.js developer job in 2027: the event loop, async patterns and the back-end skills employers testHow to get a Node.js developer job in 2027: the event loop, async patterns, APIs, security and testing skills employers test, pay and a plan.
- Career guidesHow to get an API testing or SDET job in 2027: automation, contract tests and the skills that double QA payHow to get an API testing or SDET job in 2027: test design, automation frameworks, contract and load testing, CI, pay in India and a plan.
- Career guidesHow to become a software architect in 2027: the trade-off thinking, design skills and evidence that get you the roleHow to become a software architect in 2027: styles, trade-offs, cloud patterns, decision records and the design interview, with pay in India.
- Career guidesHow to get a full-stack developer job in 2027: what "full stack" really means to employers, and how to prove itHow to get a full-stack developer job in 2027: front-end, back-end and deployment skills employers test, the interview loop, pay and a plan.
Get the ideas, not the noise.
Sign up with Google and we’ll send you short UX psychology tips by email — why people tap, stall and leave, and what to do about it. Unsubscribe anytime. Prefer something to keep? Get the free Laws of UX guide as a PDF.
You've read the playbook. Now prove it.
Take the free API Design and Integration Certification and earn API Design and Integration (SOA-APID). Free, test-based certifications graded on our server. Pass and you get a founder-signed certificate with a credential ID and QR code employers can verify.






