Implements Kafka integration for Elixir services: Broadway/Kafka consumer pipelines with backpressure, GenStage-based event processing, and efficient partition assignment for BEAM processes. Configures consumer groups leveraging Elixir's concurrency model. Implements fault-tolerant message processing with supervisor strategies.

Independently implements tasks with Elixir Phoenix. Understands internals and optimizes performance. Writes tests.

Develops GraphQL API on Absinthe with nested types, enums and interfaces. Solves N+1 problem through Dataloader and batch resolvers. Implements Relay-style pagination with cursors, configures Absinthe middleware for logging and authentication.

Independently implements tasks with NATS / NATS JetStream. Understands internals and optimizes performance. Writes tests.

Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses Ecto effectively.

Independently implements RabbitMQ messaging in Elixir with Broadway/AMQP library. Leverages OTP supervision trees for consumer fault tolerance. Configures prefetch counts and acknowledgment strategies for reliable processing.

Independently implements Redis caching patterns in Elixir services — pub/sub with Redix.PubSub for real-time features, sorted sets for leaderboards, and pipeline batching for performance. Understands Redis persistence options and memory management. Writes integration tests validating cache behavior and TTL correctness.

Independently applies algorithmic thinking in Elixir: evaluates process message routing efficiency, selects appropriate data transformation algorithms with Enum/Stream, understands recursion optimization with tail-calls. Analyzes complexity of distributed computation patterns in OTP applications.

Independently applies async programming in Elixir/OTP: GenServer async calls, Task.async/await for concurrent operations, process supervision for fault tolerance. Understands trade-offs between synchronous and asynchronous message passing in OTP.

Develops structured API documentation for Phoenix with OpenAPI through open_api_spex. Configures Swagger UI for interactive endpoint testing. Generates automatic documentation from Ecto schemas and controllers, maintains changelog and guides through ExDoc.

Independently applies immutability patterns in Elixir backend services including persistent data structures, structural sharing, and efficient transformation pipelines with Enum and Stream. Writes pure functions that transform immutable state through GenServer callbacks and process-based state isolation. Understands performance implications of immutable data copying and leverages Elixir's BEAM-optimized memory model.

Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses Ecto effectively.

Independently applies code quality practices in Elixir/OTP development. Writes clean GenServer and Supervisor implementations with proper documentation. Understands trade-offs between process isolation and shared state. Reviews code for proper error handling, pattern matching clarity, and OTP convention adherence.

Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses Ecto effectively.

Independently applies concurrency patterns in Elixir/OTP: GenServer for stateful process management, Task for fire-and-forget concurrent operations, process linking and monitoring for fault tolerance. Explains trade-offs between different OTP concurrency abstractions in code review.

Independently applies monadic patterns (with/case chains, Result tuples) for composable error handling in Elixir pipelines. Understands trade-offs between Railway-oriented programming and exception-based flows. Explains functor mapping over Ecto changesets and option types in code reviews.

Independently designs schemas and optimizes queries with query optimization. Understands indexing and query execution plans. Uses Ecto effectively.

Applies FP principles naturally in Elixir: pattern matching, immutable data, pure functions, and pipe-based transformations. Understands when to use processes vs pure functions for state management. Reviews code for side-effect isolation and proper use of GenServer callbacks.

Develops real-time functionality on Phoenix Channels with authorization through socket assigns and tokens. Implements presence tracking through Phoenix.Presence for online user tracking. Configures PubSub for distributed message broadcasting between nodes.

Independently designs schemas and optimizes queries with data modeling. Understands indexing and query execution plans. Uses Ecto effectively.

Implements API versioning in Phoenix through scope routes and Plug pipelines. Maintains parallel versions with separate controllers and view modules. Applies header-based versioning through custom Plug, ensures client migration between versions.

Independently implements tasks with caching strategies. Understands internals and optimizes performance. Writes tests.

Independently designs schemas and optimizes queries with transactions and concurrency. Understands indexing and query execution plans. Uses Ecto effectively.