AI Coding Assistants 1
▼
Uses GitHub Copilot for writing basic Elixir code: functions, pattern matching, pipe operators. Gets suggestions for Ecto queries and Phoenix controllers. Critically evaluates AI suggestions for Elixir idiomaticity and OTP patterns.
Effectively applies GitHub Copilot for accelerating Elixir development: generating ExUnit tests, Ecto migrations, Phoenix contexts. Writes precise comments and typespecs for improving suggestions. Uses Copilot Chat for explaining OTP patterns and debugging GenServer logic.
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.
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.
Algorithms & Data Structures 2
▼
Understands the fundamentals of Algorithms & Complexity at a basic level. Applies simple concepts in work tasks using Elixir. Follows recommendations from senior developers when solving problems.
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.
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 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.
Understands the fundamentals of Data Structures at a basic level. Applies simple concepts in work tasks using Elixir. Follows recommendations from senior developers when solving problems.
Independently selects appropriate data structures in Elixir: keyword lists vs maps for configuration, ETS for read-heavy concurrent data, tuples vs structs for function return types. Understands trade-offs between immutable data structures and process-based state management in OTP.
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.
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.
API Management 2
▼
Documents Elixir modules and functions through @moduledoc and @doc attributes. Generates documentation through ExDoc with mix docs. Describes Phoenix API endpoints with request and response examples, maintains typespecs for auto-documenting types in ExDoc.
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.
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.
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.
Understands the need for API versioning in Phoenix applications. Implements basic versioning through URL prefixes (/api/v1, /api/v2) using scope in Phoenix Router. Maintains backward compatibility when adding new fields to JSON responses.
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.
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.
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.
API Protocols 2
▼
Understands gRPC fundamentals in Elixir: proto file definitions, code generation with grpc-elixir, and basic unary calls. Follows team patterns for implementing gRPC services with Elixir's concurrency model and OTP supervision.
Develops gRPC services in Elixir: implements gRPC servers through grpc-elixir with streaming support, integrates with OTP supervision trees for fault tolerance. Uses GenServer patterns for stateful gRPC processing and configures Telemetry for metrics.
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.
Standardizes gRPC in the Elixir ecosystem: defines when to use gRPC vs BEAM distribution vs Phoenix Channels, creates internal wrapper libraries for simplified gRPC development. Designs patterns for integrating gRPC with GenStage/Broadway for data pipeline processing.
Implements basic WebSocket connections in Phoenix through Channels. Creates channels with join, handle_in and handle_out handling. Connects JavaScript client through phoenix.js, sends and receives messages with basic real-time event handling.
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.
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.
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.
Authentication & Authorization 1
▼
Implements basic JWT authentication in Phoenix through Guardian. Generates and verifies tokens, configures Guardian.Plug.Pipeline for route protection. Understands JWT structure (header, payload, signature) and authorization flow through Bearer tokens in API requests.
Develops full authentication system in Phoenix with Guardian and Ueberauth. Implements OAuth2 flow with providers (Google, GitHub) through Ueberauth strategies. Configures refresh tokens, revocation through ETS or Redis, and RBAC authorization through Guardian.Permissions.
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.
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.
Caching 2
▼
Uses caching strategies at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with caching strategies. Understands internals and optimizes performance. Writes tests.
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 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.
Uses Redis at a basic level in Elixir applications — connecting with Redix, executing simple GET/SET commands for session and response caching. Understands basic Redis data types and follows team practices for cache key structure and TTL management in Phoenix applications.
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.
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 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.
Clean Code & Refactoring 1
▼
Understands the fundamentals of Code Quality & Refactoring at a basic level. Applies simple concepts in work tasks using Elixir. Follows recommendations from senior developers when solving problems.
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.
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.
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.
Concurrency & Parallelism 2
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using Elixir. Follows recommendations from senior developers when solving problems.
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.
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 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.
Understands the fundamentals of Multithreading at a basic level. Applies simple concepts in work tasks using Elixir. Follows recommendations from senior developers when solving problems.
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.
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.
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.
Containerization 1
▼
Creates basic Dockerfiles for Elixir applications with multi-stage builds: compilation via mix release in the builder stage and minimal runtime image on Alpine. Runs Phoenix applications in containers with docker-compose, configures integration with PostgreSQL and Redis.
Optimizes Docker images for Elixir releases with dependency caching for mix deps.get and compilation. Configures health checks through Phoenix endpoints, manages configuration through runtime.exs and ENV variables. Implements docker-compose for full dev environment with LiveReload.
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.
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.
Data Modeling 2
▼
Creates basic Ecto schemas with field types and validations through changeset in Elixir projects. Defines has_many, belongs_to and many_to_many associations. Uses embedded_schema for nested structures and cast_assoc for validating associated data.
Independently designs schemas and optimizes queries with data modeling. Understands indexing and query execution plans. Uses Ecto effectively.
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.
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.
Creates basic Ecto migrations through mix ecto.gen.migration in Elixir projects. Adds tables, columns and indexes with proper data types. Understands migration execution order and uses mix ecto.migrate and mix ecto.rollback for schema management.
Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses Ecto effectively.
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 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.
Database Optimization 4
▼
Creates basic indexes in Ecto migrations for PostgreSQL: single-column, unique and composite. Understands index impact on SELECT query speed in Elixir applications. Uses create index and create unique_index in mix ecto.gen.migration migrations.
Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses Ecto effectively.
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.
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.
Understands sharding in Elixir: knows how Ecto supports multiple repos, understands that BEAM distribution can replace database sharding for some use cases. Can work with multi-repo Ecto configuration.
Works with sharding in Elixir: implements dynamic Ecto.Repo selection through custom middleware, applies consistent hashing through :erlang.phash2 for shard routing, configures per-shard connection pooling through DBConnection. Handles cross-shard queries through Task.async_stream.
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).
Defines data architecture for the Elixir platform: standardizes sharding approaches through Hex packages, designs hybrid architecture (BEAM distribution for hot data + PostgreSQL sharding for cold data). Defines monitoring and auto-rebalancing strategy for shards.
Writes efficient Ecto queries for PostgreSQL in Elixir applications. Avoids N+1 problems through Ecto.Query.preload, uses select for fetching needed fields. Understands the difference between preload, join and subquery in the context of performance.
Independently designs schemas and optimizes queries with query optimization. Understands indexing and query execution plans. Uses Ecto effectively.
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.
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.
Uses basic transactions in Elixir through Ecto.Repo.transaction/1 for atomic operations. Understands ACID concepts in the context of PostgreSQL and Ecto. Handles transaction errors through pattern matching on {:ok, result} and {:error, reason}.
Independently designs schemas and optimizes queries with transactions and concurrency. Understands indexing and query execution plans. Uses Ecto effectively.
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 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.
Event-Driven Architecture 1
▼
Understands CQRS in Elixir: knows Commanded framework, understands how GenServer and Elixir's process model naturally support CQRS. Can work with an existing Commanded-based project, adding simple command handlers.
Implements CQRS in Elixir: uses Commanded for aggregates and process managers, configures EventStore for event persistence, creates read projections through Commanded.Projections.Ecto. Applies Elixir pattern matching for event handling and validation.
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.
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.
Functional Programming 3
▼
Understands the fundamentals of Functional Programming Principles at a basic level. Applies simple concepts in work tasks using Elixir. Follows recommendations from senior developers when solving problems.
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.
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.
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.
Understands basic immutability principles in Elixir — all data structures are immutable by default. Follows team patterns for working with immutable maps, lists, and structs without attempting mutation. Recognizes how pattern matching and function composition replace traditional mutable state manipulation in Elixir codebases.
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.
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.
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.
Understands the fundamentals of Monads & Functors at a basic level. Applies simple concepts in work tasks using Elixir. Follows recommendations from senior developers when solving problems.
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.
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.
Defines monad and functor usage standards at team/product level. Conducts architectural reviews. Establishes best practices and training materials for the team.
Git & Workflows 1
▼
Uses basic Git commands in Elixir projects: commit, push, pull, branch. Understands .gitignore structure for Elixir: _build, deps, .elixir_ls. Creates feature branches for tasks, resolves simple merge conflicts in Elixir modules and mix.lock files.
Applies advanced Git practices in Elixir teams: interactive rebase for clean history, cherry-pick for backporting fixes. Sets up pre-commit hooks for automatic mix format and mix credo execution. Resolves complex conflicts in Ecto migrations and config files.
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.
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.
GraphQL 1
▼
Creates basic GraphQL schemas in Elixir using Absinthe. Defines types, queries and mutations through Absinthe DSL. Connects resolvers to Phoenix Ecto contexts, returns data with basic error handling through {:ok, data} and {:error, message}.
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.
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.
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.
Integration Testing 1
▼
Writes basic integration tests for Phoenix applications with Ecto sandbox. Tests endpoints through ConnTest with HTTP requests, verifies JSON responses and status codes. Uses setup blocks for preparing test data in PostgreSQL through Ecto factories.
Develops integration tests for Elixir services with real PostgreSQL through Ecto.Adapters.SQL.Sandbox. Tests Phoenix Channels through ChannelTest, WebSocket connections and PubSub. Implements tests for Broadway pipelines with producer mocking through Mox.
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.
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.
Logging 1
▼
Uses built-in Logger in Elixir for basic logging in Phoenix applications. Applies Logger.debug/info/warning/error levels with metadata. Understands BEAM VM log structure, configures output format through Logger.Formatter in config.exs.
Configures structured logging in Elixir projects through Logger with JSON formatting. Adds metadata (request_id, user_id) through Logger.metadata/1 in Plug pipeline. Integrates logs with ELK stack through LogstashJSON, implements request correlation between services.
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.
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.
Message Queues & Event Streaming 4
▼
Uses Apache Kafka at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
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.
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.
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.
Understands message broker patterns in Elixir/OTP: pub-sub with Broadway, work queues via GenStage. Follows team conventions for consuming messages from RabbitMQ/Kafka using built-in concurrency primitives and supervision trees.
Works with messaging in Elixir: uses Broadway for concurrent message processing from RabbitMQ/Kafka/SQS, configures GenStage for internal event processing pipeline. Applies OTP supervisor patterns for fault-tolerant message processing with automatic restart.
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.
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.
Uses NATS / NATS JetStream at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with NATS / NATS JetStream. Understands internals and optimizes performance. Writes tests.
Designs NATS JetStream-based messaging for Elixir microservices. Implements exactly-once delivery patterns with Elixir consumers. Optimizes subject hierarchies for multi-tenant OTP applications.
Defines architectural decisions for NATS / NATS JetStream at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Uses RabbitMQ at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
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.
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.
Defines architectural decisions for RabbitMQ at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
OOP & Design Patterns 1
▼
Understands the fundamentals of Design Patterns at a basic level. Applies simple concepts in work tasks using Elixir. Follows recommendations from senior developers when solving problems.
Independently applies design patterns for Elixir: GenServer for stateful processes, Supervisor trees for fault tolerance, pipeline pattern with |> operator for data transformations, behaviour callbacks for polymorphism. Explains pattern trade-offs for OTP-based architectures.
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.
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.
Relational Databases 1
▼
Performs basic SQL queries to PostgreSQL through Ecto in Elixir projects. Creates simple schemas with fields, types and associations (has_many, belongs_to). Uses Ecto.Query for selections, filtering and sorting data in Phoenix applications.
Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses Ecto effectively.
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.
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.
REST API 1
▼
Creates basic REST endpoints in Phoenix Framework using controllers and router. Defines resource routes through resources/4, implements CRUD operations with Ecto schemas. Returns JSON responses through Phoenix.Controller.json/2 with proper HTTP status codes.
Develops structured REST APIs on Phoenix with versioning through router scopes. Implements pagination, filtering and sorting through Ecto queries. Applies Phoenix.View or Jason.Encoder for serialization, configures Plug pipelines for authentication.
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.
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.
System Design 1
▼
Understands basic principles of high-load systems on Elixir/OTP. Knows BEAM VM advantages for concurrent processing: lightweight processes, preemptive scheduling, fault tolerance through supervision trees. Applies basic scaling patterns for Phoenix applications.
Implements components of high-load Elixir systems: GenServer pools for hot data, Broadway for stream processing with back-pressure, ETS for in-memory caching. Configures Phoenix PubSub for distributed notifications, optimizes Ecto queries for load.
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.
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.
Web Frameworks 1
▼
Uses Elixir Phoenix at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with Elixir Phoenix. Understands internals and optimizes performance. Writes tests.
Designs solutions based on Elixir Phoenix for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.
Defines architectural decisions for Elixir Phoenix at product level. Establishes standards. Conducts design reviews and defines technical roadmap.