Independently implements tasks with Apache Kafka in actix-web/axum. Understands internals and optimizes performance. Writes tests with cargo test.

Develops gRPC services on tonic with server/client streaming, interceptors for authentication and request metadata. Configures tonic-build for code generation, implements error mapping through tonic::Status and connects reflection service for grpcurl.

Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses diesel/sea-orm effectively.

Independently implements tasks with Redis in actix-web/axum. Understands internals and optimizes performance. Writes tests with cargo test.

Independently implements tasks with Rust Web Frameworks in actix-web/axum. Understands internals and optimizes performance. Writes tests with cargo test.

Independently applies algorithmic thinking in Rust: selects iterator-based algorithms for zero-copy processing, understands ownership model impact on algorithm design, evaluates concurrent algorithm patterns with atomics and channels. Analyzes complexity of data processing in systems-level Rust code.

Independently applies async programming in Rust: tokio/async-std runtime, Future composition with async/await, pinning and lifetime management in async contexts. Understands trade-offs between sync and async Rust, task spawning vs structured concurrency.

Implements Rust generics with trait bounds: writes generic functions and structs with where clauses and multiple trait bounds. Understands monomorphization and its impact on binary size vs runtime performance. Applies lifetime parameters in generic contexts ('a), combines generics with trait objects (dyn Trait) when dynamic dispatch is needed. Uses PhantomData for zero-cost type-level markers.

Develops comprehensive API documentation for Rust services: OpenAPI 3.0 through utoipa with examples, authentication description (SecurityScheme), grouping by tags. Configures automated documentation generation in CI and publishing through Swagger UI/Redoc.

Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses diesel/sea-orm effectively.

Independently applies code quality practices in Rust development. Writes clean code with clear ownership semantics, proper error types, and ergonomic APIs. Understands trade-offs between generics complexity and API usability. Reviews code for unsafe usage, lifetime correctness, and trait design clarity.

Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses diesel/sea-orm effectively.

Independently applies multithreading in Rust: Send/Sync trait system for thread safety guarantees, Arc<Mutex> for shared state, tokio runtime for async concurrency, crossbeam for lock-free data structures. Explains Rust ownership model advantages for concurrent code in review.

Independently designs schemas and optimizes queries with query optimization. Understands indexing and query execution plans. Uses diesel/sea-orm effectively.

Independently applies design patterns for Rust: trait-based strategy and visitor patterns, builder for complex struct construction, newtype pattern for type safety, state machine pattern with enums. Explains Rust-specific pattern choices considering ownership and lifetimes.

Independently applies SOLID principles in Rust: trait-based polymorphism instead of inheritance, single responsibility in module/crate design, dependency inversion through trait objects and generics. Understands Rust-specific OOP trade-offs — composition over inheritance, trait coherence rules, zero-cost abstractions.

Independently designs schemas and optimizes queries with data modeling and schema design. Understands indexing and query execution plans. Uses diesel/sea-orm effectively.

Independently uses DHAT, heaptrack, and Valgrind/Massif to profile Rust application memory. Understands how ownership patterns and borrow checker semantics affect allocation behavior and chooses profiling strategies accordingly.

Implements API versioning in Rust services through Axum middleware or Actix-web guards, supporting multiple versions simultaneously. Applies serde with #[serde(default)] and #[serde(skip_serializing_if)] for backward-compatible JSON schema evolution.

Independently implements tasks with caching strategies in actix-web/axum. Understands internals and optimizes performance. Writes tests with cargo test.

Independently selects appropriate data structures in Rust: Vec vs VecDeque for sequential data, HashMap vs BTreeMap for keyed lookups, Arc<Mutex> vs channels for shared state. Understands trade-offs between ownership patterns and data structure borrowing semantics.

Independently applies Rust's type system for backend services — leveraging ownership and borrowing for memory safety, using enums with associated data for state machines, and applying trait bounds for generic service abstractions. Understands trade-offs between dynamic dispatch and monomorphization. Explains lifetime annotations and type-level programming to colleagues.

Applies Rust ownership model effectively: understands move semantics, borrowing rules, and lifetime annotations. Uses Box, Rc, Arc appropriately for heap allocation patterns. Handles interior mutability with RefCell and Mutex. Understands stack vs heap allocation trade-offs and when to use references vs owned values.