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.
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.
Defines algorithmic strategy at the entire Elixir/OTP platform level. Develops specialized data structures for distributed computing on BEAM node cluster, optimizes message routing and load balancing between processes through :pg and Registry.
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.
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.
Develops data storage architectural patterns for distributed Elixir systems. Designs custom CRDT structures for eventual consistency between nodes, defines ETS, Mnesia and :persistent_term usage strategy at the entire platform level.
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.
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.
Develops platform documentation strategy for the Elixir ecosystem. Designs unified API catalog with automatic service discovery, versioning and interactive testing. Implements documentation culture through ExDoc, Livebook and mandatory @doc/@spec.
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.
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.
Develops API evolution strategy at the entire organizational level. Defines breaking changes standards, sunset policy and migration paths for Elixir services. Designs platform for automatic incompatibility detection between versions through typed contracts.
API Protocols 1
▼
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.
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.
Develops real-time communication strategy for the entire organization on Phoenix. Designs distributed WebSocket architecture on BEAM node cluster with automatic channel sharding. Defines LiveView, Channels and SSE standards for various scenarios.
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.
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.
Develops caching architecture at the entire Elixir platform level. Defines ETS, Mnesia, Cachex and Redis usage standards for various scenarios. Designs predictive cache warming systems, automatic invalidation and efficiency monitoring through :telemetry.
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.
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.
Defines platform caching strategy for distributed Elixir systems. Designs hybrid solutions with ETS, :persistent_term, Cachex and Redis Cluster. Develops cache-aside, write-through pattern standards and invalidation policies at organizational level.
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.
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.
Shapes Elixir code quality standards at the entire organizational level. Develops custom Credo rules, defines typespec and @behaviour usage policies, implements property-based testing through StreamData as mandatory practice for critical modules.
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 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.
Defines concurrent processing strategy at the entire Elixir/OTP platform level. Designs data flow architecture based on GenStage, Broadway and Flow for processing millions of events per second. Optimizes BEAM VM schedulers for specific workloads.
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.
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.
Defines concurrency strategy for the entire Elixir platform at BEAM VM level. Optimizes scheduler operations, configures dirty schedulers for NIF calls, designs distributed process systems through :pg, Registry and distributed Erlang.
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.
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.
Develops data modeling strategy at the entire organizational level. Defines DDD standards with Ecto contexts and bounded contexts, designs inter-domain integration through events. Implements CQRS with Commanded for complex business domains in the Elixir ecosystem.
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.
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.
Defines platform database schema management standards for the Elixir ecosystem. Develops automation for backward compatibility migration checks, designs migration strategy for sharded and multi-tenant systems with Ecto prefix and Triplex.
Database Optimization 3
▼
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.
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.
Develops platform PostgreSQL indexing standards for the Elixir ecosystem. Defines index analysis automation, designs policies for partitioned tables and distributed databases. Implements CI migration checks for required indexes.
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.
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.
Defines query optimization strategy at the entire organizational level. Designs CQRS architecture with separate Ecto.Repos for reads and writes, implements read replicas. Develops platform tools for automatic Ecto query analysis and optimization.
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.
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 transactional integrity standards for the entire Elixir platform. Designs distributed transactions through two-phase commit based on GenServer and Ecto.Multi. Develops compensating transaction framework for eventual consistency between microservices.
Distributed Tracing 1
▼
Integrates OpenTelemetry into Elixir applications through opentelemetry_api and opentelemetry_exporter. Sets up automatic instrumentation for Phoenix and Ecto through opentelemetry_phoenix and opentelemetry_ecto. Understands concepts of spans, traces and context propagation in BEAM.
Implements distributed tracing in Elixir services through OpenTelemetry SDK. Creates custom spans for GenServer calls and Broadway pipelines, configures context propagation between processes through :otel_ctx. Exports traces to Jaeger/Tempo with proper correlation.
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.
Develops platform distributed tracing strategy for the Elixir ecosystem. Designs complete observability stack: OpenTelemetry for traces, :telemetry + Prometheus for metrics, Logger for logs. Defines signal correlation standards and automated analysis through Grafana Tempo.
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.
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 functional architecture for the entire Elixir platform. Develops macro-based DSLs for domain areas, designs libraries with protocols and behaviours. Implements algebraic data types and contract programming through typespecs and Dialyzer.
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.
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.
Shapes the organization's approach to immutable data architecture in Elixir and functional programming ecosystems. Drives innovation in immutability patterns for distributed Elixir systems including CRDTs, immutable audit trails, and append-only data stores. Influences the Elixir community through contributions to libraries and patterns that advance immutable system design at scale.
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.
Defines monad and functor usage standards at team/product level. Conducts architectural reviews. Establishes best practices and training materials for the team.
Defines monad and functor strategy at organizational level. Makes decisions on approaches and tools. Mentors lead developers and shapes technical vision.
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.
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.
Develops platform GraphQL architecture for the entire organization on Absinthe. Designs Graph Federation with automatic schema composition, defines API evolution policy and breaking changes. Implements distributed query cache through ETS and Redis.
Message Queues & Event Streaming 3
▼
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.
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.
Develops platform strategy for event-driven architecture with Kafka for the Elixir ecosystem. Designs Avro/Protobuf schemas for inter-service communication, defines retention and replication policies. Ensures exactly-once semantics through Broadway and Kafka transactions.
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.
Defines architectural decisions for NATS / NATS JetStream at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Defines NATS / NATS JetStream strategy at company level. Evaluates new technologies and approaches. Establishes enterprise standards and reference architectures.
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.
Defines architectural decisions for RabbitMQ at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Defines RabbitMQ strategy at company level. Evaluates new technologies and approaches. Establishes enterprise standards and reference architectures.
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.
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.
Defines PostgreSQL strategy at the entire organizational Elixir ecosystem level. Designs distributed data schemas with Citus, configures logical replication for event sourcing. Develops Ecto usage standards, migration and optimization practices at platform level.
Test Strategy 1
▼
Understands the fundamentals of property-based testing with StreamData and ExUnitProperties. Writes basic property tests for pure Elixir functions. Follows team conventions for generator definitions and test structure.
Implements property-based tests in Elixir using StreamData. Defines generators for basic types and Ecto schemas, writes properties for verifying business logic invariants. Integrates StreamData with ExUnit through use ExUnitProperties for automatic test case generation.
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 property-based testing strategy for the organizational Elixir platform. Develops StreamData framework with generators for all domains, integrates stateful testing for distributed systems. Implements model-based testing for OTP behaviour verification.
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.
Defines architectural decisions for Elixir Phoenix at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Defines Elixir Phoenix strategy at company level. Evaluates new technologies and approaches. Establishes enterprise standards and reference architectures.