SDK and Client Library Design Questions

Packaging an API for developer consumption via SDKs and client libraries: ergonomic method surfaces, auth handling, pagination helpers, retry/backoff built in, error mapping, and versioning of generated or hand-written clients. Covers cloud/mobile SDK design, code generation from contracts, and keeping SDKs consistent across languages.

MediumTechnical

48 practiced

You operate a public API with many SDK consumers. Propose an SDK compatibility and release strategy that ensures minor server changes do not break clients. Include semantic versioning, deprecation tooling, backwards-compatible API layers, automatic integration tests between SDKs and staging endpoints, and documentation generation.

Sample Answer

MediumTechnical

43 practiced

Design an approach for library code to emit logs without overwhelming consumers: how would you structure log levels, allow injection of a logger, and keep default behavior quiet while enabling verbose logs for debugging? Provide example API surface for the library logger integration.

Sample Answer

HardTechnical

61 practiced

You need to design first-party SDKs for your public API in Python, JavaScript, and Java. Describe SDK responsibilities (authentication helpers, retries, pagination helpers, typed models), release and versioning strategy (semantic versioning, deprecation windows), error mapping, and how to automate SDK generation from API contracts while preserving idiomatic language patterns.

Sample Answer

MediumTechnical

54 practiced

Implement a Python module that batches outbound HTTP API calls up to N requests per second and maps responses back to original callers. The module should support per-call timeouts, retries, and an asynchronous interface (asyncio). Provide clear pseudocode showing batching, concurrency, and error handling.

Sample Answer

To solve this, use an asyncio-based batching worker that collects requests into a batch window (1 second or when batch size reached), issues a single upstream call (or parallel calls constrained by rate N/s), and maps responses back via Futures. Support per-call timeout/retries by tracking attempts and using asyncio.wait_for. pythonimport asyncio from typing import Any, Dict, List, Tuple import time class BatchClient: def __init__(self, n_per_sec: int, batch_size: int = 50, max_retries: int = 2): self.n_per_sec = n_per_sec self.batch_size = batch_size self.max_retries = max_retries self._queue = asyncio.Queue() self._tokens = n_per_sec self._last_refill = time.monotonic() self._worker = asyncio.create_task(self._batch_worker()) async def call(self, payload: Dict, timeout: float = 2.0) -> Any: fut = asyncio.get_running_loop().create_future() await self._queue.put((payload, fut, timeout, 0)) # attempt=0 return await asyncio.wait_for(fut, timeout=timeout + 0.1) # allow mapping time async def _refill_tokens(self): now = time.monotonic() elapsed = now - self._last_refill if elapsed >= 1.0: self._tokens = self.n_per_sec self._last_refill = now async def _batch_worker(self): while True: await self._refill_tokens() batch = [] # gather up to batch_size or until queue empty or tokens exhausted while len(batch) < self.batch_size and self._tokens > 0: try: item = self._queue.get_nowait() except asyncio.QueueEmpty: break batch.append(item) if not batch: # wait for first item or token refill item = await self._queue.get() batch.append(item) # respect rate limit to_send = min(len(batch), self._tokens) send_items = batch[:to_send] remaining = batch[to_send:] for r in remaining: await self._queue.put(r) # put back unused self._tokens -= to_send # build batched payload batched_payload = [p for (p, _, _, _) in send_items] # send upstream with retries per item mapping try: responses = await self._send_batched(batched_payload) # map responses to futures (assumes 1:1 order) for (_, fut, _, _), resp in zip(send_items, responses): if not fut.done(): fut.set_result(resp) except Exception as exc: # on failure, schedule retries per item for payload, fut, timeout, attempt in send_items: if attempt < self.max_retries: await self._queue.put((payload, fut, timeout, attempt + 1)) else: if not fut.done(): fut.set_exception(exc) await asyncio.sleep(0) # yield async def _send_batched(self, batched_payload: List[Dict]) -> List[Any]: # PSEUDOCODE: replace with real HTTP client, e.g., aiohttp # Example: await aiohttp.post(..., json=batched_payload) await asyncio.sleep(0.05) # simulate network return [{"status": "ok", "data": p} for p in batched_payload] Key points: Uses asyncio.Queue to decouple callers from sender. Rate limiting via token refill per second; batch triggers when queue has items. Per-call Future maps responses back; per-call timeout handled with asyncio.wait_for. Retries: failed batch re-enqueues items with attempt count. Complexity: O(m) per batch where m=batch_size; memory O(Q) queued requests. Edge cases: upstream returns partial failures, reordering, long per-call timeouts — handle by including request IDs and matching responses. Alternatives: use leaky-bucket or token-bucket libraries, or shard workers for higher throughput.

HardTechnical

56 practiced

Propose a strategy for automatic SDK migration when an API introduces a breaking change. Discuss how to generate migration patches, notify consumers, roll out compatibility shims in SDKs, and measure adoption of automated migrations across multiple languages and pinned dependency versions.

Sample Answer

Unlock Full Question Bank

Get access to all 6 SDK and Client Library Design interview questions and detailed answers.

Join thousands of developers preparing for their dream job.