What a Senior } should know

Applies algorithmic expertise in Elixir development: flow-based processing algorithms with GenStage backpressure, distributed consensus algorithms in clustered OTP applications, efficient recursion with tail-call optimization. Designs algorithms for process supervision tree balancing and load distribution.

Designs async architectures in Elixir/OTP: GenStage-based backpressure pipelines, distributed task coordination across nodes, supervision tree design for fault-tolerant async workflows. Mentors team on OTP concurrency patterns.

Designs code quality standards for Elixir/OTP projects: Credo configuration, dialyzer specifications, process architecture patterns. Refactors GenServer hierarchies for fault tolerance and clarity. Establishes review practices for concurrency patterns, supervision trees, and hot code upgrades.

Selects optimal data structures for Elixir/OTP applications: ETS tables for concurrent read-heavy workloads, process-based state isolation, persistent term storage for configuration. Optimizes data flow through GenStage pipelines with backpressure-aware buffering. Designs efficient message passing structures between distributed Erlang nodes.

Has deep expertise in design patterns for Elixir/OTP: designs fault-tolerant architectures with supervision strategies, implements domain-driven patterns adapted for functional programming, optimizes GenServer and process patterns for scalability. Mentors team on OTP design patterns for distributed Elixir systems.

Designs Elixir systems with deep FP expertise: supervision trees with pure business logic separated from side effects, data pipelines using Stream and Flow for backpressure-aware processing. Mentors team on monadic error handling with with-expressions and proper use of behaviours.

Designs Elixir application architectures that maximize the benefits of immutability for concurrency safety and fault tolerance. Implements advanced patterns including ETS-backed caching with immutable snapshots, event sourcing with immutable event logs, and CQRS architectures leveraging immutable command and event structures. Optimizes data transformation pipelines by understanding structural sharing and binary copy semantics in the BEAM VM.

Designs composable middleware pipelines using monadic patterns in Elixir (Plug chains, Ecto.Multi transaction composition). Architects error-handling strategies combining with-clauses, tagged tuples, and supervision trees. Mentors developers on algebraic thinking and when to avoid monadic abstractions in favor of OTP patterns.

Has deep expertise in Elixir/OTP concurrency: designs fault-tolerant distributed systems with supervision trees, implements backpressure and flow control in GenStage pipelines, optimizes process scheduling for high-throughput systems. Mentors team on advanced OTP patterns for production Elixir applications.

Integrates Apache Kafka into Elixir applications through Broadway with KafkaBroadway adapter. Configures consumer groups, manages offset commits and partitions. Implements message processing with back-pressure and automatic process scaling through Broadway.

Implements multi-level caching in Elixir applications: ETS for hot in-memory data, Cachex with TTL policies, Redis for distributed cache. Applies :persistent_term for rarely changing configurations, configures invalidation through Phoenix PubSub.

Designs solutions based on Elixir Phoenix for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.

Designs messaging architecture for Elixir systems: defines boundaries between BEAM distribution and external brokers, implements event sourcing through Commanded framework, configures Broadway with custom acknowledger for exactly-once semantics. Optimizes concurrent processing through process pooling.

Designs NATS JetStream-based messaging for Elixir microservices. Implements exactly-once delivery patterns with Elixir consumers. Optimizes subject hierarchies for multi-tenant OTP applications.

Designs RabbitMQ messaging architecture for Elixir/OTP systems. Implements custom Broadway producers with backpressure, shovel/federation for cluster bridging. Optimizes consumer concurrency leveraging BEAM scheduler capabilities.

Integrates Redis into Elixir applications through Redix or Cachex library with Redis backend. Implements Phoenix session caching, Ecto query result caching and rate limiting. Configures connection pool through NimblePool and manages TTL strategies.

Designs connection management for Elixir systems: configures multi-repo architecture with separate pools for read replicas, implements connection warming through start_link init, designs PgBouncer integration for connection multiplexing. Solves prepared statement issues with PgBouncer.

Designs complex data models with Ecto for PostgreSQL: polymorphic associations, STI through type field, JSONB columns with Ecto.Type. Implements custom Ecto.Types for domain-specific types, applies Ecto.Changeset for complex business validation with contexts.

Designs indexing strategy for PostgreSQL in Elixir projects. Creates partial, GIN, GiST and BRIN indexes through Ecto migrations with execute/1. Analyzes query plans through EXPLAIN ANALYZE, optimizes indexes for Ecto queries with preload and join.

Implements complex Ecto migrations for PostgreSQL: safe column addition with defaults, data migrations through execute/1, concurrent index creation. Applies Ecto.Migration.flush/0 for multi-stage migrations and ensures schema backward compatibility.

Designs sharding for Elixir systems: implements custom Ecto adapter for transparent sharding, designs resharding with GenServer-based coordinator, uses BEAM distribution as "shards" for stateful data in ETS/Mnesia. Optimizes connection management through database proxy (PgBouncer).

Optimizes PostgreSQL usage in Elixir through advanced Ecto capabilities: multi-tenant architecture with prefix, window functions through fragments, CTEs and recursive queries. Configures Ecto.Repo with connection pool through DBConnection for high loads.

Optimizes complex Ecto queries to PostgreSQL: CTEs through fragments, window functions, materialized views. Analyzes EXPLAIN ANALYZE to identify seq scans and nested loops. Applies Ecto.Multi and stream for processing large datasets without OOM.

Implements complex transactional scenarios through Ecto.Multi for operation chains with rollback. Configures PostgreSQL isolation levels for concurrent Elixir processes. Applies advisory locks through Ecto for coordination between GenServer processes and cluster nodes.

Designs API documentation system for Elixir projects with auto-generation from typespecs and open_api_spex. Implements contract testing through specifications, configures CI validation of documentation freshness. Creates interactive examples with Livebook for complex integrations.

Designs API versioning strategy for Phoenix minimizing code duplication. Implements content negotiation through Accept headers and custom MIME types. Implements deprecation policy with warnings in response headers and version usage monitoring.

Designs scalable GraphQL APIs on Absinthe with subscriptions through Phoenix PubSub and WebSocket. Implements persisted queries, query complexity analysis and depth limiting for DoS protection. Implements schema federation and Phoenix LiveView integration through push updates.

Designs gRPC integration for Elixir systems: uses BEAM distribution for internal communication and gRPC for cross-language interaction, configures connection management considering BEAM scheduler, implements deadline propagation through process metadata. Optimizes for high concurrency.

Designs rate limiting for Elixir systems: implements distributed rate limiting through BEAM distribution with :global or Horde, configures Redis-based limiting for multi-node clusters, designs backpressure through GenStage demand. Optimizes ETS access patterns for concurrent rate checking.

Designs scalable REST APIs on Phoenix with HATEOAS and content negotiation. Implements rate limiting through Hammer, caching through ETag and ConCache. Implements API gateway with Plug.Router, configures documentation through OpenAPI with open_api_spex and Swagger UI.

Designs scalable WebSocket systems on Phoenix with LiveView for real-time server rendering. Optimizes Phoenix.PubSub for millions of subscriptions, configures clustering through pg2/Phoenix.PubSub.PG2. Implements graceful degradation with long polling.

Designs AWS infrastructure for the Elixir platform. Configures ECS/EKS with BEAM clustering through libcluster and AWS Cloud Map. Implements event-driven architecture with SQS, SNS and Broadway. Optimizes costs through Spot Instances with graceful process draining.

Designs production-ready Docker infrastructure for Elixir applications. Configures multi-stage builds with optimal layer caching, configures Elixir releases with --no-halt. Implements graceful shutdown through SIGTERM in supervision tree, configures network isolation.

Designs Kubernetes infrastructure for distributed Elixir systems. Configures StatefulSets for BEAM clustering with libcluster, Headless Services for node discovery. Implements canary deployments, configures PodDisruptionBudget for preserving Elixir cluster quorum.

Designs advanced CI/CD pipelines for Elixir on GitHub Actions. Implements incremental compilation with caching, parallel test execution through mix test --partitions. Configures automatic Docker image builds with Elixir releases and Kubernetes deployment.

Designs integration testing strategy for the Elixir platform. Implements end-to-end tests through Wallaby with headless Chrome for LiveView. Configures distributed system testing with multiple BEAM nodes, mocks external APIs through Bypass and Tesla.Mock.

Designs comprehensive property-based testing for Elixir projects through StreamData. Creates custom generators for complex domain objects, implements stateful tests for GenServer. Applies shrinking for minimizing failing cases, tests Ecto queries and protocols.

Designs test architecture for Elixir applications: isolation through Ecto sandbox mode, concurrent tests with async: true. Implements contract testing through Mox with verify_on_exit!, property-based through StreamData. Configures ExCoveralls for coverage reports in CI.

Designs secure authentication system for Elixir microservices. Implements centralized auth through Guardian with JWT RS256 and JWKS key rotation. Implements OAuth2 server through ExOAuth2Provider, configures SSO and token introspection for inter-service authorization.

Designs comprehensive OWASP threat protection for Elixir services. Implements SAST through Sobelow for static analysis of Phoenix code, configures WAF rules. Implements protection against SSRF, deserialization attacks through safe :erlang.binary_to_term with [:safe] option.

Designs secure Elixir application architecture. Implements least privilege principle through Guardian and RBAC authorization. Implements audit logging through :telemetry, configures data encryption through Cloak.Ecto. Conducts security code reviews focusing on OTP-specific vulnerabilities.

Integrates AI tools into Elixir development workflow: Copilot for boilerplate generation, Claude for architectural decisions. Creates prompt templates for generating idiomatic Elixir code. Critically evaluates AI suggestions for OTP best practices compliance.

Designs CQRS architecture for Elixir systems: configures multiple read models through Commanded projections, implements event upcasting for schema evolution, optimizes aggregate loading through snapshot strategy. Integrates CQRS with Phoenix LiveView for real-time updates.

Designs high-load systems on Elixir/OTP for handling millions of connections. Configures BEAM clustering through libcluster, optimizes schedulers and GC. Implements event sourcing through Commanded, CQRS with separate Ecto.Repos for reads and writes.

Designs distributed Elixir systems with microservice architecture on BEAM. Defines service boundaries through DDD, implements inter-service communication through distributed Erlang or gRPC with Protobuf. Designs resilient systems with circuit breaker through Fuse and bulkhead patterns.

Designs distributed tracing architecture for the Elixir platform through OpenTelemetry. Implements automatic instrumentation for custom OTP behaviours, configures sampling strategies for high-load systems. Implements trace correlation with logs and :telemetry metrics.

Designs monitoring system for the Elixir platform on Prometheus and Grafana. Implements custom PromEx plugins for domain metrics, configures alerting rules for SLO/SLI. Implements RED metrics for microservices, monitoring GenServer mailbox size and process reductions.

Designs logging system for the Elixir platform with JSON structure and distributed tracing. Implements OpenTelemetry through opentelemetry_api with automatic span_id and trace_id correlation. Configures Logger backends for Datadog/Grafana Loki delivery, implements sampling for high loads.

Conducts deep architectural reviews of Elixir systems: evaluates supervision tree design, concurrent pattern correctness, Ecto query efficiency. Identifies potential issues: process leaks, GenServer bottlenecks, suboptimal ETS strategies. Mentors through reviews.

Designs Git workflow for Elixir projects: trunk-based development with feature flags through FunWithFlags, release branches for Elixir releases. Configures advanced hooks: typespec validation through Dialyzer, migration validation. Automates changelog through conventional commits.