Independently implements tasks with Apache Kafka in Play/http4s. Understands internals and optimizes performance. Writes tests with ScalaTest/MUnit.

Optimizes connection pooling in Scala: configures Slick with custom HikariCP configuration, uses doobie with HikariTransactor for functional database access, implements connection lifecycle through cats-effect Resource. Monitors pool through JMX and Kamon.

Implements CQRS in Scala: uses Akka Typed Persistence for event sourced aggregates, configures Akka Projection for read models, applies ZIO + Tapir for typed command/query API. Implements domain events with sealed trait hierarchies for exhaustive matching.

Implements gRPC services in Scala through ScalaPB and Akka gRPC: unary and server-streaming RPC, error handling through Status, deadline propagation. Designs Protobuf schemas with evolution in mind, uses oneof for polymorphism and configures interceptors for logging and authentication.

Develops gRPC services in Scala: uses Akka gRPC or ZIO gRPC for implementing services with streaming, integrates with Akka Streams for backpressure-aware processing. Configures ScalaPB transformations for customizing generated code.

Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses Slick/Doobie effectively.

Implements rate limiting in Scala services: uses Akka Streams throttle for flow control, configures ZIO with Semaphore for concurrent limiting, implements distributed limiting through Redis. Applies Play Framework filters for per-request rate limiting.

Independently implements tasks with Redis in Play/http4s. Understands internals and optimizes performance. Writes tests with ScalaTest/MUnit.

Designs REST API in Scala services following best practices: HATEOAS links, pagination, filtering through query parameters. Implements content negotiation, proper error handling through ADT and middleware for logging in Play Framework or Akka HTTP Directives.

Independently implements tasks with Scala Frameworks in Play/http4s. Understands internals and optimizes performance. Writes tests with ScalaTest/MUnit.

Independently applies algorithmic thinking in Scala: selects functional collection algorithms for data transformation, understands lazy evaluation impact on memory, evaluates parallel collection performance trade-offs. Analyzes complexity of Spark operations and distributed computation patterns.

Independently applies async programming in Scala: ZIO/Cats Effect fibers, Future composition, effect system-based concurrency. Understands trade-offs between Future-based and effect system-based async patterns in Scala applications.

Applies Scala's advanced type parameter system: upper/lower type bounds ([A <: B], [A >: B]), variance annotations (covariant +A, contravariant -A). Implements type classes via implicit parameters and context bounds ([T: Ordering]). Uses existential types and type members for abstraction, understands type inference limitations in complex generic chains.

Creates complete API documentation for Scala services through Tapir with OpenAPI specification auto-generation: describes all endpoints, error schemas, examples. Documents Protobuf contracts, writes ADR (Architecture Decision Records) for key architectural decisions.

Independently applies immutability patterns in Scala services using persistent collections, lenses for nested updates, and algebraic data types for state modeling. Writes transformation pipelines with immutable data flow using for-comprehensions, monadic composition, and functional effect systems. Understands performance trade-offs between immutable and mutable structures for hot paths and chooses appropriate strategies.

Independently designs schemas and optimizes queries with Database Indexing. Understands indexing and query execution plans. Uses Slick/Doobie effectively.

Independently applies code quality practices in Scala development. Writes clean functional code with appropriate use of effect systems and type classes. Understands trade-offs between expressive type-level programming and code readability. Reviews code for proper error handling, implicits scope, and build dependency management.

Independently designs schemas and optimizes queries with Database Migrations. Understands indexing and query execution plans. Uses Slick/Doobie effectively.

Independently applies multithreading in Scala: Akka actors for message-passing concurrency, Cats Effect/ZIO fibers for lightweight concurrency, Future composition for async workflows. Explains trade-offs between actor model and effect-based concurrency in code review.

Independently uses monads (Option, Either, Future, IO) for effect management in Scala applications. Understands trade-offs between Cats Effect and ZIO for referential transparency. Explains functor laws and for-comprehension desugaring to colleagues in code reviews.

Independently designs schemas and optimizes queries with Query Optimization. Understands indexing and query execution plans. Uses Slick/Doobie effectively.

Confidently uses Scala FP idioms: case classes for immutable data, Option/Either for error handling, pattern matching, and for-comprehensions. Understands the trade-offs between OOP and FP styles in Scala. Applies FP principles in code review and explains monadic composition to colleagues.

Works with messaging in Scala ecosystem: uses Alpakka Kafka with Akka Streams for reactive processing, configures consumer groups with committable sources, implements at-least-once delivery through offset committing. Applies fs2-kafka for functional stream processing with cats-effect.

Independently applies design patterns for Scala: type class pattern for ad-hoc polymorphism, cake pattern for dependency injection, monad transformers for composable effects, sealed trait hierarchies for algebraic data types. Explains FP-oriented pattern alternatives.

Independently applies OOP/SOLID in Scala: proper trait composition and mixin linearization, case class design for immutable data, sealed trait hierarchies for algebraic data types. Understands trade-offs between OOP and FP approaches in Scala — when to use classes vs type classes, objects vs functions.

Independently designs schemas and optimizes queries with Data Modeling and Schema Design. Understands indexing and query execution plans. Uses Slick/Doobie effectively.

Designs and implements API versioning strategies using content negotiation, custom media types, or path-based versioning in Scala microservices. Writes migration guides and automated contract tests for version transitions.

Independently implements tasks with Caching Strategies in Play/http4s. Understands internals and optimizes performance. Writes tests with ScalaTest/MUnit.

Independently selects appropriate data structures in Scala: immutable List vs Vector for sequential data, LazyList for deferred evaluation, case classes for domain modeling. Understands trade-offs between Scala's persistent data structures and Java interop collections.

Independently applies Scala's type system for backend services — using sealed traits for ADTs, type class patterns with implicits/givens, and higher-kinded types for effect abstractions. Understands trade-offs between type-level encoding complexity and runtime safety. Explains variance annotations and type inference to colleagues.

Independently designs schemas and optimizes queries with Transactions and Concurrency. Understands indexing and query execution plans. Uses Slick/Doobie effectively.

Works with sharding in Scala: implements database routing through custom Slick DatabaseProvider, uses Akka Cluster Sharding for distributed entity management. Applies functional programming patterns (Reader monad) for shard-aware data access.