API and interface design

you put one component in front of all the services to do auth, rate limiting and routing once instead of in each of them.

API gateway

you build a separate thin API for the mobile app so it stops being shaped by whatever the web client needed.

Backend for frontend

you make the endpoint a PUT with a client-chosen id, so a nervous client can send it three times without creating three records.

Idempotent HTTP method

the mobile client needs two fields and the endpoint returns a forty-field object with three nested collections.

Over-fetching

you ask for page 400 and the database dutifully reads and discards the first eight thousand rows to get there.

Offset pagination

you return an opaque token pointing at the last row, so page fifty costs the same as page one and nothing shifts under the client.

Cursor pagination

you cap each client at a hundred requests a minute and start returning 429 once they go over.

Rate limiting

you let clients save up allowance while idle and spend it in a burst, as long as the long-run average stays under the limit.

Token bucket

the client makes a request and you hold it open for thirty seconds, only answering when something actually happens.

Long polling

you upgrade the connection once and then push messages in both directions without a new request each time.

WebSocket

instead of your client polling for changes, you POST to a URL they gave you whenever something happens.

Webhook

you renamed the field and every client that was reading it starts getting nulls in production.

Breaking change

you add the field as optional so the clients that have never heard of it keep working unchanged.

Backward compatibility

your parser ignores fields it does not recognise, so a newer producer can add one without breaking you.

Forward compatibility

you put /v2 in the path because the change you need cannot be made without breaking the callers on /v1.

API versioning

you change the message format and have to make sure the consumers still on the old schema can read the new messages.

Schema evolution

you announce the endpoint is going away, keep it running for six months, and watch the traffic to find out who is still on it.

Deprecation window

you wrap the legacy system's awkward model in a translation layer so its concepts do not leak into your new code.

Anti-corruption layer