Backend Development

Designing the contract: REST conventions that actually matter (idempotency, pagination, versioning), GraphQL's trade, and how to choose.

JavaScript on the server — the event loop explained properly, a real Express API, and the one rule that keeps Node fast: never block.

The enterprise standard: dependency injection as a framework, the controller→service→repository layering, JPA, and what @Transactional really does.

Type hints as the framework: Pydantic validation, async endpoints, dependency injection, and free OpenAPI docs — plus where Django fits.

How data relates — one-to-one, one-to-many / many-to-one, and many-to-many — mapped from tables (foreign keys, join tables) to ORM entities, plus the gotchas that bite in production: owning vs inverse side, lazy vs eager loading, the N+1 query, cascades, and creating linked entities inside one transaction.

Who are you, and what may you do: password storage done right, sessions vs JWT honestly, the OAuth dance, and RBAC.

Where caches live, the five read/write patterns (cache-aside, read/write-through, write-behind, refresh-ahead), and the failure modes that actually break production: stampede, penetration, avalanche, and the dual-write race.

When request/response is the wrong shape: polling vs SSE vs WebSocket, the upgrade handshake, and the pub/sub backplane that makes it scale.

Splitting the backend honestly: what microservices buy, the distributed problems they import, sagas, and why monolith-first is the senior answer.

The front door and the phone book of microservices: edge concerns in one place, how services find each other, and where the mesh fits.

The log vs the queue: partitions, consumer groups, offsets and replay — versus exchanges, acks and routing — and how to pick between them.

Mutual exclusion across machines: Redis locks with TTLs, why fencing tokens exist, and the senior move — designing so you don't need the lock at all.

Move slow work off the request path: job queues, at-least-once delivery and idempotent consumers, retries with backoff + jitter, dead-letter queues, the transactional outbox, and why exactly-once is mostly a myth.

Domain-Driven Design as the boundary-drawing discipline: bounded contexts, aggregates, domain events — and the modular monolith that makes microservices optional.