What a Junior } should know

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.

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.

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.

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.

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.

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.

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.

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.

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.

Uses Apache Kafka at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.

Uses caching strategies at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.

Uses Elixir Phoenix at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.

Uses NATS / NATS JetStream at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.

Uses RabbitMQ at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.

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.

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.

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.

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.

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.

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.

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}.

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.

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.

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}.

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.

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.