What a Lead } should know

Designs algorithmically optimal solutions for high-load Elixir systems on BEAM VM. Analyzes complexity of concurrent algorithms considering OTP process scheduler, evaluates impact on latency when processing millions of messages through GenServer and Task.

Designs complex asynchronous systems on Elixir using Task.Supervisor, GenStage and Flow for parallel data processing. Manages back-pressure through Broadway, configures process pools and controls concurrency through Task.async_stream.

Implements comprehensive code quality system for Elixir projects: Credo for linting, Dialyzer for static type analysis through typespecs, ExUnit for test coverage. Configures CI pipeline with mix format, mix credo --strict and dialyzer as mandatory checks.

Designs efficient immutable data structures for Elixir applications considering BEAM VM memory model. Applies ETS/DETS tables for high-speed data access, optimizes :persistent_term usage for global configurations in the cluster.

Adapts design patterns for idiomatic Elixir using OTP behaviours. Implements GenServer, Supervisor, GenStage and Broadway for building resilient data processing pipelines. Trains the team on applying functional patterns and protocols.

Applies advanced functional patterns in Elixir: monadic chains through with, protocols for polymorphism, macros for metaprogramming. Designs modular systems with pure functions, pipe operators and pattern matching for complex business logic.

Defines immutability-first architectural standards for Elixir backend systems across the organization. Establishes team guidelines for leveraging immutable data structures in distributed system designs, process state management, and inter-service communication protocols. Conducts architecture reviews ensuring immutability principles are consistently applied for concurrency safety and system reliability.

Defines monad and functor usage standards at team/product level. Conducts architectural reviews. Establishes best practices and training materials for the team.

Designs concurrent Elixir systems based on BEAM VM lightweight processes and OTP patterns. Applies GenServer, Agent and Task for safe parallelism through message passing, configures supervision trees for fault tolerance and manages process state.

Designs architecture of event-driven Elixir systems based on Kafka and Broadway. Defines partitioning strategy, configures batching and concurrent processing through Broadway pipelines. Implements dead letter queues, lag monitoring through :telemetry and Prometheus.

Designs comprehensive caching strategy for Elixir/Phoenix applications. Implements cache-aside through Cachex with Telemetry metrics, configures distributed cache through Redis Cluster. Defines TTL, LRU eviction and invalidation policies for each data level.

Defines architectural decisions for Elixir Phoenix at product level. Establishes standards. Conducts design reviews and defines technical roadmap.

Standardizes messaging in the Elixir ecosystem: designs architecture with Commanded for CQRS/ES, implements EventStore for durable event log, creates internal libraries for standardizing Broadway pipelines. Defines patterns for distributed saga through process managers.

Defines architectural decisions for NATS / NATS JetStream at product level. Establishes standards. Conducts design reviews and defines technical roadmap.

Defines architectural decisions for RabbitMQ at product level. Establishes standards. Conducts design reviews and defines technical roadmap.

Designs caching architecture for Elixir systems using Redis, ETS and Cachex. Defines multi-level strategy: L1 — in-process ETS, L2 — Redis cluster. Configures hit rate monitoring through :telemetry and Prometheus, implements cache invalidation.

Standardizes connection management for the Elixir platform: creates library for standard Ecto pool setup with observability, defines pool sizing strategy based on BEAM schedulers and workload. Designs connection governance for multi-node BEAM cluster.

Defines data model architecture for the Elixir platform. Designs bounded contexts through separate Ecto schemas and Phoenix contexts. Implements event sourcing with Commanded/EventStore, defines aggregate and value object modeling standards through embedded_schema.

Defines PostgreSQL indexing policy for all Elixir services. Implements automatic monitoring of unused indexes through pg_stat_user_indexes and :telemetry. Designs strategy for creating indexes concurrently through Ecto migrations without downtime.

Designs migration strategy for the Elixir platform with zero-downtime deployments. Implements two-phase migrations (expand/contract), configures CI safety checks through Excellent Migrations. Defines schema versioning policy and rollback procedures for all services.

Designs PostgreSQL data architecture for the Elixir platform. Defines partitioning, replication and sharding strategy. Implements Ecto.Multi for transactional integrity of complex operations, configures query monitoring through Ecto.LogEntry and :telemetry.

Designs query monitoring and optimization system for the Elixir platform. Implements pg_stat_statements through :telemetry for tracking slow queries. Defines Ecto query writing standards, configures alerts on performance degradation through Prometheus.

Designs transactional architecture for distributed Elixir systems. Implements Saga pattern through Ecto.Multi and GenServer for cross-service operations. Defines optimistic locking strategy through Ecto.Changeset.optimistic_lock and conflict handling.

Defines API documentation standards for all organizational Elixir services. Implements developer portal with ExDoc, OpenAPI specifications and Livebook examples. Designs automatic SDK generation from specifications and documentation versioning system.

Defines API versioning policy for all Elixir services. Designs architecture with API Gateway on Phoenix for routing between versions. Implements automated backward compatibility testing through open_api_spex and contract tests at CI level.

Defines GraphQL strategy for the Elixir platform. Designs federated architecture with Absinthe Federation, defines naming standards, error handling and authorization through middleware. Implements schema stitching between microservices and monitoring through :telemetry.

Standardizes rate limiting in the Elixir ecosystem: creates Hex package for standard rate limiting setup, designs centralized rate limit configuration through Etcd/Consul, implements Telemetry metrics for rate limit observability. Defines API quota management for Phoenix-based APIs.

Defines REST API architectural standards for all organizational Elixir services. Designs Phoenix API Gateway with Guardian/JWT authentication, versioning and rate limiting. Implements contract-first approach with open_api_spex and client auto-generation.

Defines real-time system architecture for the Elixir platform based on Phoenix Channels and LiveView. Designs PubSub scaling through Redis or distributed Erlang, defines messaging protocol standards. Implements connection monitoring through :telemetry.

Defines AWS cloud architecture for all organizational Elixir services. Designs Infrastructure as Code through Terraform with modules for Phoenix services. Implements multi-account strategy, configures centralized logging and monitoring through CloudWatch and :telemetry.

Defines containerization standards for all organizational Elixir services. Designs base Docker images with precompiled OTP and Elixir, configures CI/CD pipelines for building releases. Implements vulnerability scanning through Trivy and image update policies.

Defines Kubernetes architecture for the organizational Elixir platform. Designs Helm charts with templates for Phoenix services, configures service mesh for inter-node communication. Implements GitOps through ArgoCD with automatic rollback based on :telemetry metrics.

Defines CI/CD standards for all organizational Elixir projects on GitHub Actions. Creates reusable workflows for typical Elixir pipelines. Implements quality gates: Dialyzer, Credo, ExCoveralls >90%, mix audit and migration checks.

Defines integration testing standards for all Elixir services. Implements contract testing between microservices through Pact, configures CI environment with docker-compose for the full stack. Designs testing strategy for GenServer clusters and distributed Erlang.

Implements property-based testing as a standard practice across all Elixir projects. Defines testing strategy through StreamData for critical modules, trains the team on writing properties and generators. Creates a library of common generators for organizational domain objects.

Defines unit testing standards for all organizational Elixir projects. Implements mandatory >90% coverage through ExCoveralls, defines testing patterns for GenServer, Broadway and Ecto contexts. Creates shared helpers and factories on ExMachina for all services.

Defines authentication and authorization strategy for the entire Elixir platform. Designs Identity Provider on Phoenix with Guardian, OAuth2 and OpenID Connect. Implements zero-trust architecture with mTLS between services, centralized permission management through PolicyWonk.

Defines OWASP security standards for all organizational Elixir services. Implements mandatory Sobelow in CI, conducts threat modeling for Phoenix applications. Designs security middleware through Plug for centralized protection, organizes regular security code reviews.

Defines secure coding standards for Elixir teams. Implements security linting through Sobelow and Credo rules, creates secure coding guidelines for Phoenix and OTP. Designs secrets architecture through Vault with rotation, organizes security training for developers.

Defines AI tool usage standards for Elixir teams. Implements GitHub Copilot with custom rules for Elixir/Phoenix projects, creates guidelines for validating AI-generated code. Trains the team on effective AI usage for OTP and functional programming.

Standardizes CQRS in the Elixir ecosystem: defines architectural boundaries for bounded contexts, designs inter-aggregate communication through domain events, creates testing utilities for aggregate and projection verification. Trains teams on DDD + CQRS + ES on Elixir.

Defines architecture of high-load Elixir systems for the organization. Designs distributed BEAM clusters with automatic node discovery, balancing through consistent hashing. Implements capacity planning based on :telemetry metrics and load testing through Tsung.

Defines architectural standards for the organizational Elixir platform. Designs reference architecture with Phoenix, Ecto, Broadway and distributed OTP. Implements ADR (Architecture Decision Records), conducts architectural reviews and defines system evolution strategy.

Defines observability standards through OpenTelemetry for all Elixir services. Designs unified instrumentation with opentelemetry_api for Phoenix, Ecto, Broadway and distributed Erlang. Implements trace-based testing, configures SLO monitoring based on traces with adaptive sampling.

Defines monitoring standards for all Elixir services through Prometheus and Grafana. Designs dashboard hierarchy: platform, service, business metrics. Implements SLO-based alerting, configures Grafana templates for typical Elixir/Phoenix services with PromEx metrics.

Defines logging standards for all organizational Elixir services. Designs unified structured log schema with mandatory fields through custom Logger backend. Implements centralized logging through Grafana Loki with Elixir-specific dashboards and anomaly alerts.

Defines code review standards for organizational Elixir teams. Implements automated checks through Credo, Dialyzer and Sobelow in the PR process. Designs review guidelines for Phoenix, OTP and Ecto code, defines checklist for architectural reviews of distributed systems.

Defines Git strategy for all organizational Elixir projects. Implements trunk-based development with automated merge via CI when Dialyzer, Credo and ExUnit are green. Designs monorepo or umbrella application strategy, configures CODEOWNERS for Phoenix contexts.