What a Junior } should know

Understands the fundamentals of Algorithms & Complexity at a basic level. Applies simple concepts in work tasks using Rust. 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 Rust. 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 Rust. 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 Rust. 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 Rust. Follows recommendations from senior developers when solving problems.

Understands the fundamentals of Generics & Parametric Polymorphism at a basic level. Applies simple concepts in work tasks using Rust. Follows recommendations from senior developers when solving problems.

Understands the fundamentals of Memory Management at a basic level. Applies simple concepts in work tasks using Rust. Follows recommendations from senior developers when solving problems.

Understands the fundamentals of Memory Profiling at a basic level. Applies simple concepts in work tasks using Rust. Follows recommendations from senior developers when solving problems.

Understands the fundamentals of Multithreading at a basic level. Applies simple concepts in work tasks using Rust. Follows recommendations from senior developers when solving problems.

Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using Rust. Follows recommendations from senior developers when solving problems.

Understands the fundamentals of Type Safety & Type Systems at a basic level. Applies simple concepts in work tasks using Rust. Follows recommendations from senior developers when solving problems.

Uses Apache Kafka at a basic level in actix-web/axum. Performs simple tasks using established templates. Understands basic concepts and follows team practices.

Uses caching strategies at a basic level in actix-web/axum. Performs simple tasks using established templates. Understands basic concepts and follows team practices.

Uses Redis at a basic level in actix-web/axum. Performs simple tasks using established templates. Understands basic concepts and follows team practices.

Uses Rust Web Frameworks at a basic level in actix-web/axum. Performs simple tasks using established templates. Understands basic concepts and follows team practices.

Designs simple data models for Rust applications, creating struct definitions with derive(sqlx::FromRow) or Diesel schemas. Understands mapping between Rust types and PostgreSQL, uses Option<T> for nullable fields and enum types through sqlx::Type.

Creates basic PostgreSQL indexes for Rust applications, understanding the connection between query types in SQLx/Diesel and required indexes. Uses EXPLAIN to analyze query plans and adds B-tree indexes for frequently used WHERE conditions.

Creates basic migrations for Rust projects through refinery or sqlx migrate, understanding schema versioning principles. Writes idempotent UP/DOWN migrations, adds tables and columns with proper data types and constraints.

Performs basic CRUD operations with PostgreSQL from Rust through SQLx or Diesel using type-safe queries with compile-time verification. Understands Rust type mapping to SQL types (String->TEXT, i32->INTEGER) and works with connection pools through sqlx::PgPool.

Optimizes simple SQL queries in Rust applications by analyzing EXPLAIN output and avoiding N+1 problems when loading related data. Uses batch queries through SQLx query_as instead of loop calls and adds pagination through LIMIT/OFFSET.

Documents REST API of Rust services through utoipa attributes (#[utoipa::path]) on Axum/Actix-web endpoints. Describes request/response schemas through derive(ToSchema) and generates Swagger UI through utoipa-swagger-ui middleware.

Understands API versioning principles in Rust services: URL-based (/v1/, /v2/), header-based approaches. Implements basic versioning through separate route modules in Axum/Actix-web and maintains compatibility when adding new fields through Option<T>.

Implements basic gRPC services in Rust through tonic, defining .proto files and using Rust code auto-generation through prost. Understands Protobuf message structure, unary RPC calls and proto type mapping to Rust structs.

Implements basic REST endpoints on Actix-web or Axum using extractors for request parsing and serde for JSON serialization. Understands HTTP methods, status codes and routing structure in Rust web frameworks.

Understands basic networking concepts for Rust backend services — TCP/UDP socket programming, HTTP/HTTPS with hyper/reqwest, and DNS resolution. Follows team guidelines for configuring TLS in Rust services and debugging connection issues with tokio network primitives.