AI Coding Assistants 1
▼
Uses GitHub Copilot for writing basic Scala code: function autocompletion, generating boilerplate for case classes and pattern matching. Understands AI generation limitations for Scala-specific syntax, verifies suggested code for type correctness and compilability.
Effectively applies GitHub Copilot for Scala development: generating unit tests in ScalaTest, creating Doobie/Slick queries, writing Akka HTTP routes. Uses prompt engineering for idiomatic Scala code, critically evaluates suggestions considering functional patterns and type safety.
Optimizes AI tool usage for Scala projects: configuring Copilot/Cursor for ZIO/Cats Effect, custom instructions for project conventions. Reviews AI-generated code for security, evaluates generation quality for complex type-level Scala constructs.
Defines AI tool usage standards for Scala team: guidelines for reviewing AI-generated code, custom rules for Copilot. Implements AI-assisted refactoring for legacy Scala code, trains team on effective prompting for functional patterns and effect systems.
Algorithms & Data Structures 2
▼
Understands the fundamentals of Algorithms & Complexity at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Applies algorithmic expertise in Scala development: parallel collection algorithms for multi-core processing, functional stream processing with Akka Streams/fs2, recursive algorithm optimization with trampolining. Designs distributed computation algorithms for Spark workloads with proper partition strategies.
Conducts reviews of team algorithmic decisions in Scala projects, evaluates O-complexity of critical paths in Akka Streams and Spark pipelines. Defines performance standards for services and implements benchmarks through JMH to identify JVM-level bottlenecks.
Understands the fundamentals of Data Structures at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Selects optimal data structures for Scala applications: immutable persistent collections for functional patterns, TrieMap for concurrent access, Vector for balanced append/prepend performance. Optimizes data structure choices in Spark RDD/Dataset operations. Designs type-safe custom collections using Scala's collection framework with proper implicit evidence.
Defines standards for using Scala immutable collections and persistent data structures in team projects. Reviews data structure choices considering GC pressure on JVM, optimizes Vector, HashMap and TreeMap usage in high-load services.
API Management 2
▼
Documents Scala API endpoints using Swagger/OpenAPI annotations: describes request/response models, request examples. Writes Scaladoc comments for public methods, maintains up-to-date README with service launch instructions and available endpoints.
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.
Designs API documentation system for Scala microservices: auto-generation through Tapir/Smithy, CI integration for freshness validation. Creates developer portal with interactive examples, documents inter-service interaction patterns and error handling strategies.
Defines API documentation standards for Scala team: mandatory sections, specification format, documentation review process. Implements contract-first approach through Tapir or Smithy, ensures documentation-code synchronization through automated checks in CI/CD pipeline.
Studies API versioning strategies including URI versioning and content negotiation in Scala services. Follows established patterns for version management in Akka HTTP or Play Framework endpoints.
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.
Designs API architecture with API Versioning Strategies for production systems. Defines versioning standards, error handling, pagination. Optimizes performance.
Defines API versioning strategy for Scala team: choosing between URL-path, header-based and content negotiation approaches. Implements deprecation processes with grace period, automated backward compatibility checking through Tapir schema diff and old API version usage monitoring.
API Protocols 1
▼
Understands gRPC fundamentals in Scala: proto file definitions, code generation with ScalaPB, and basic unary calls. Follows team patterns for implementing gRPC services with Akka gRPC or ZIO gRPC functional streaming.
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.
Designs gRPC architecture for Scala microservices: integrates with Akka Cluster for distributed gRPC services, implements service discovery through Akka Discovery, configures gRPC with Kamon/OpenTelemetry for observability. Optimizes production gRPC server configuration on Akka HTTP.
Standardizes gRPC development in Scala ecosystem: chooses between Akka gRPC, ZIO gRPC and fs2-grpc for different teams, creates sbt plugins for standardizing proto generation, designs patterns for functional error handling in gRPC. Defines testing strategy with akka-grpc-testkit.
Application Security 1
▼
Familiar with main OWASP Top 10 vulnerabilities in Scala development context: SQL injection through parameterized queries in Doobie, XSS protection in Play Framework templates. Understands input validation importance and uses built-in framework security mechanisms.
Applies OWASP practices in Scala services: CSRF protection in Play Framework, CORS policy configuration in Akka HTTP, safe JSON deserialization through Circe. Implements input validation through refined types, prevents mass assignment and configures security headers for HTTP responses.
Conducts security review of Scala services against OWASP Top 10: dependency analysis through sbt-dependency-check, code scanning through Snyk/SonarQube. Implements protection against SSRF, ReDoS and deserialization attacks, configures Content Security Policy and designs secure APIs with rate limiting.
Defines OWASP security standards for Scala team: mandatory security checks in CI, code review checklist, vulnerability management. Implements SAST/DAST tools for sbt projects, conducts threat modeling for new services and defines CVE response process.
Caching 2
▼
Uses Caching Strategies at a basic level in Play/http4s. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with Caching Strategies in Play/http4s. Understands internals and optimizes performance. Writes tests with ScalaTest/MUnit.
Designs caching architecture for Scala services: Caffeine with functional wrappers, distributed caching with Cats Effect/ZIO integration. Implements cache coherence strategies for actor-based systems and event-driven invalidation patterns.
Defines architectural decisions for Caching Strategies at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Uses Redis at a basic level in Play/http4s. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with Redis in Play/http4s. Understands internals and optimizes performance. Writes tests with ScalaTest/MUnit.
Implements advanced caching patterns in Scala services through Redis4Cats or Lettuce: cache-aside, write-through, distributed locks. Configures TTL strategies, serialization through Circe/Protobuf and hit rate monitoring for optimizing Akka HTTP and Play Framework endpoint performance.
Defines caching strategy for Scala microservices team: Redis Cluster usage standards, invalidation policies, distributed sessions. Reviews caching architecture considering data consistency, implements multi-layer caching with local Caffeine and distributed Redis.
CI/CD 1
▼
Understands basic GitHub Actions workflow structure for Scala projects: sbt compile, sbt test, caching .ivy2 and .sbt directories. Can read CI/CD pipeline logs, fix broken builds and understands push and pull request trigger concepts.
Configures CI/CD pipelines for Scala projects: parallel test execution through sbt, Coursier dependency caching, Docker image builds through sbt-native-packager. Configures matrix builds for different Scala/JDK versions, integrates Scoverage for coverage reports.
Designs CI/CD pipelines for Scala microservices: multi-stage pipeline with unit/integration/e2e tests, security scanning through Snyk, automatic deployment through ArgoCD. Optimizes sbt build time through incremental compilation and remote caching, configures release workflow with semantic versioning.
Defines CI/CD standards for Scala team: mandatory pipeline stages, quality gates (coverage, lint), trunk-based development strategy. Implements reusable workflows for sbt projects, configures automated dependency updates through Scala Steward and integrates performance regression testing.
Clean Code & Refactoring 1
▼
Understands the fundamentals of Code Quality & Refactoring at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Designs code quality standards for Scala projects: Scalafix rules, Wartremover configurations, effect system patterns (ZIO/Cats Effect). Refactors imperative code to functional style with proper type-level programming. Establishes review practices for implicits usage, type class patterns, and build organization.
Implements Scala code quality standards in the team: configuring Scalafix, WartRemover, Scalafmt. Defines code review rules emphasizing idiomatic Scala, correct implicits usage and for-comprehension. Integrates static analysis and coverage metrics into CI/CD pipeline through sbt.
Code Review 1
▼
Participates in Scala code reviews as a reviewer: checks readability, naming, adherence to project conventions. Learns from reviewers — analyzes received comments, asks questions about functional patterns and idiomatic Scala style in pull requests.
Conducts quality Scala code reviews: evaluates correctness of implicits usage, for-comprehension, pattern matching exhaustiveness. Checks error handling through MonadError, concurrent code correctness in ZIO/Cats Effect and adherence to project architectural patterns.
Conducts deep architectural code reviews in Scala projects: evaluates type-safety, effect management correctness, performance. Reviews API design, typeclass pattern usage, Akka Actor hierarchy and suggests refactorings for improving composability and testability.
Defines code review standards for Scala team: review checklist, response time SLA, approval rules. Mentors reviewers, implements automated code review through Scalafix rules and Danger, ensures constructive review atmosphere and learning through feedback.
Concurrency & Parallelism 2
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Designs async architectures in Scala: ZIO/Cats Effect-based service composition, fiber-based concurrency patterns, effect system resource management. Mentors team on functional concurrency patterns and effect system best practices.
Establishes asynchronous programming standards for the team: choosing between ZIO, Cats Effect and Akka for specific tasks. Reviews correctness of effect management, fibers and concurrent structures, ensures absence of blocking calls in the main execution thread.
Understands the fundamentals of Multithreading at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Has deep expertise in Scala concurrency: designs effect-based concurrent systems with ZIO/Cats Effect fibers, implements actor-based distributed processing with Akka Cluster, optimizes JVM concurrency for Scala-specific patterns. Mentors team on functional concurrency patterns for production Scala systems.
Defines thread pool management policies for Scala services: ExecutionContext configuration, blocking and compute pools for ZIO/Cats Effect. Conducts team concurrent code audits, identifies race conditions and deadlocks through fiber graph analysis and JVM thread dumps.
Data Modeling 2
▼
Creates basic data models for Scala applications: defines case classes for domain entities, maps them to PostgreSQL tables through Doobie or Slick. Understands normalization to 3NF, designs simple table relationships and uses Scala types to express model constraints.
Independently designs schemas and optimizes queries with Data Modeling and Schema Design. Understands indexing and query execution plans. Uses Slick/Doobie effectively.
Designs domain data models for Scala services: applies DDD approach with sealed trait ADTs for states, JSONB for flexible structures, temporal tables for auditing. Optimizes schemas considering access patterns, implements efficient serialization through Circe and Doobie codecs.
Defines data modeling standards for Scala team: schema design rules, table naming, JSONB vs normalization usage. Reviews domain models for bounded context alignment, implements Event Sourcing models with Akka Persistence for critical aggregates.
Understands database migration fundamentals in Scala: Flyway/Liquibase integration with sbt, versioned SQL migrations, and basic schema changes with type-safe libraries like Slick or Doobie. Follows team patterns for migration scripts and rollback procedures.
Independently designs schemas and optimizes queries with Database Migrations. Understands indexing and query execution plans. Uses Slick/Doobie effectively.
Designs database migration architecture for Scala applications: implements expand-contract pattern for zero-downtime migrations, designs type-safe migration frameworks with Flyway callbacks and Slick code generation, and automates migration testing in CI/CD pipelines. Mentors team on safe schema evolution.
Defines product-level data strategy. Establishes Database Migration standards. Conducts data schema and scaling strategy reviews.
Database Optimization 4
▼
Understands connection pooling in Scala: knows HikariCP as JVM standard, can configure through Play Framework or Slick configuration. Understands connection lifecycle in context of functional IO (cats-effect Resource, ZIO Scope).
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.
Designs connection management for Scala microservices: implements functional connection routing (Reader monad for database selection), configures Akka Streams integration with database pool for backpressure-aware data access. Optimizes pool for reactive streaming workloads.
Standardizes connection management in Scala ecosystem: defines when to use Slick vs doobie vs Quill with different pool strategies, creates abstractions for standardized pool setup. Designs connection governance for Akka Cluster and distributed Scala systems.
Understands basic PostgreSQL indexing principles: creating B-tree indexes, reading EXPLAIN ANALYZE for simple queries from Scala applications. Knows the difference between primary key and regular index, can identify index needs from slow query logs.
Independently designs schemas and optimizes queries with Database Indexing. Understands indexing and query execution plans. Uses Slick/Doobie effectively.
Designs indexing strategy for Scala services: composite indexes, partial indexes, GIN for JSONB fields, GiST for geodata. Analyzes query plans considering Doobie/Slick query access patterns, optimizes indexes for reducing latency of high-load endpoints.
Defines indexing policy for Scala microservices team: naming standards, index creation rules in migrations, unused index monitoring. Reviews indexing plans considering write amplification and INSERT/UPDATE performance impact in OLTP scenarios.
Performs basic SQL query optimization in Scala applications: avoids N+1 problems in Doobie/Slick, uses JOIN instead of subqueries. Can read PostgreSQL EXPLAIN output and understands missing index impact on query performance.
Independently designs schemas and optimizes queries with Query Optimization. Understands indexing and query execution plans. Uses Slick/Doobie effectively.
Optimizes complex queries in Scala services: rewrites Slick/Doobie queries to minimize round-trips, uses batch fetching, window functions and materialized views. Profiles queries through pg_stat_statements, eliminates bottlenecks in critical service paths.
Establishes query optimization standards for Scala team: mandatory EXPLAIN analysis in code review, endpoint latency budgets, query caching rules. Reviews data access architecture, implements CQRS pattern for separating read/write workloads.
Understands fundamentals of database transactions and ACID properties in Scala applications. Uses basic transaction management with Slick, Doobie, or JDBC. Follows team conventions for transaction boundaries, proper resource cleanup, and handling concurrent access with appropriate isolation levels.
Independently designs schemas and optimizes queries with Transactions and Concurrency. Understands indexing and query execution plans. Uses Slick/Doobie effectively.
Designs transaction architectures for high-load Scala systems using advanced patterns like saga, outbox, and event sourcing for distributed consistency. Implements STM for in-memory concurrency alongside database transactions. Optimizes transaction throughput with connection pool tuning and batch processing. Mentors team on concurrency.
Defines product-level data strategy. Establishes Transactions and Concurrency standards. Conducts data schema and scaling strategy reviews.
Distributed Tracing 1
▼
Understands basic OpenTelemetry concepts for Scala applications: traces, spans, context propagation. Uses existing instrumentation for debugging requests through Jaeger/Zipkin, finds slow sections in trace waterfall and understands distributed trace structure across microservices.
Integrates OpenTelemetry into Scala services: Akka HTTP/Play instrumentation through otel4s, custom spans for business operations. Configures trace export to Jaeger/Tempo, adds span attributes for log and metric correlation, implements sampling strategy to reduce overhead.
Designs distributed tracing for Scala microservices: end-to-end instrumentation through otel4s with ZIO/Cats Effect, W3C Trace Context propagation through gRPC and Kafka. Configures tail-based sampling, custom SpanProcessors for data enrichment and trace-log correlation through OpenTelemetry Collector.
Defines OpenTelemetry observability standards for Scala team: mandatory instrumentation, semantic conventions, sampling policies. Implements OpenTelemetry Collector pipeline, configures traces + metrics + logs integration, defines SLI based on trace data for key user journeys.
Functional Programming 3
▼
Understands the fundamentals of Functional Programming Principles at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Designs production Scala systems using advanced FP: effect systems with Cats Effect or ZIO, tagless final encoding, and type-level programming. Architects services with pure core and thin I/O boundary. Mentors team on monad transformers, free monads, and functional error handling at scale.
Defines Functional Programming Principles usage standards at team/product level. Conducts architectural reviews. Creates best practices and training materials for the entire team.
Understands basic immutability principles in Scala — val vs var, immutable collections from scala.collection.immutable, and case class benefits. Follows team conventions for using immutable data structures and avoids mutable state in business logic. Recognizes how immutability enables safer concurrent programming and easier reasoning about code behavior.
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.
Designs Scala application architectures that leverage immutability for type-safe, concurrent, and testable systems. Implements advanced patterns including optics libraries (Monocle) for deep immutable updates, tagless final with immutable state, and event-sourced architectures using immutable event streams. Optimizes immutable data structures for high-throughput scenarios with structural sharing, specialized persistent collections, and strategic use of local mutability behind pure interfaces.
Defines immutability and functional programming standards for Scala backend systems across the organization. Establishes guidelines for immutable domain modeling, pure state management in distributed services, and safe interop boundaries with mutable Java libraries. Conducts architecture reviews ensuring immutability principles drive system correctness, testability, and maintainability at scale.
Understands the fundamentals of Monads & Functors at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Designs effect systems using monad transformers (EitherT, OptionT, ReaderT) and tagless final encoding for production Scala services. Architects domain layers with free monads or ZIO/Cats Effect for testable, composable business logic. Mentors developers on monad laws, stack-safe recursion with Eval, and pragmatic FP trade-offs.
Defines Monads and Functors usage standards at team/product level. Conducts architectural reviews. Creates best practices and training materials for the entire team.
Git & Workflows 1
▼
Proficient in basic Git operations for Scala projects: creating branches, commits with meaningful messages, push/pull. Understands team's gitflow or trunk-based workflow, can resolve simple merge conflicts in sbt build files and Scala code.
Uses advanced Git operations in Scala projects: interactive rebase for clean history, cherry-pick for backports, bisect for finding regressions. Configures git hooks for running scalafmt before commit, works with submodules for shared Protobuf definitions between services.
Designs Git strategy for Scala microservices: monorepo vs multirepo, branching strategy, release management. Configures automated versioning through sbt-dynver, implements trunk-based development with feature flags, manages inter-service dependencies through dependency graph.
Defines Git strategy for Scala team: commit message standards (Conventional Commits), branch protection rules, merge strategy. Implements automated changelog through sbt-release, configures CODEOWNERS for critical file reviews and defines release branch management process.
gRPC 1
▼
Uses existing gRPC services from Scala code through ScalaPB: calls unary RPC methods, understands .proto file structure. Can generate Scala classes from Protobuf definitions through sbt plugin, works with basic message types and enums.
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.
Designs gRPC API for Scala microservices: bidirectional streaming through Akka gRPC/FS2-gRPC, retry policies, load balancing. Implements Schema Registry for Protobuf, builds gRPC-Web for browser clients and optimizes performance through connection multiplexing and compression.
Defines gRPC interaction standards for Scala team: .proto file design rules, backward compatibility strategy, mandatory metadata fields. Reviews Protobuf schemas, implements buf for linting and breaking change detection, configures gRPC health checks for Kubernetes readiness probes.
Integration Testing 1
▼
Understands basics of integration testing for Scala services. Writes simple tests verifying Akka HTTP routes and database interactions using ScalaTest with embedded databases. Follows team testing guidelines for actor system integration validation.
Writes integration tests for Scala services through Testcontainers-Scala: tests Doobie/Slick queries with real PostgreSQL, Kafka producers and consumers. Configures test environment through docker-compose, verifies HTTP endpoint correctness through Akka HTTP TestKit.
Designs integration testing strategy for Scala microservices: contract testing through Pact, end-to-end tests with Testcontainers for full stack. Implements Akka Cluster testing with multi-node-test-kit, configures isolated test environments with embedded Kafka and PostgreSQL.
Defines integration testing standards for Scala team: mandatory contract tests between services, shared test fixtures. Reviews test infrastructure, implements consumer-driven contract testing through Pact, configures parallel integration test execution in CI with data isolation.
Message Queues & Event Streaming 2
▼
Uses Apache Kafka at a basic level in Play/http4s. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with Apache Kafka in Play/http4s. Understands internals and optimizes performance. Writes tests with ScalaTest/MUnit.
Designs reliable Kafka integrations in Scala services through Alpakka Kafka or FS2-Kafka: configures partitioning, exactly-once semantics and error handling. Implements Transactional Outbox and idempotent consumer patterns for message delivery guarantees in distributed Akka systems.
Defines event interaction architecture between Scala services through Kafka: Schema Registry standards with Avro/Protobuf, partitioning and retention strategies. Reviews team topic topology, implements Dead Letter Queue patterns and consumer lag monitoring through Prometheus.
Understands message broker patterns in Scala: pub-sub with Akka Streams/ZIO Streams, Kafka integration via Alpakka. Follows team conventions for functional message processing with effect systems and backpressure handling.
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.
Designs messaging architecture for Scala: implements exactly-once processing through Kafka transactions with Alpakka, designs event sourcing with Akka Persistence or EventStoreDB, configures stream processing with Flink/Kafka Streams through Scala API. Optimizes backpressure and parallelism.
Standardizes messaging in Scala ecosystem: chooses between Alpakka, fs2-kafka and ZIO Kafka for different teams, designs event-driven architecture with CQRS through Akka Projection, implements schema registry integration with Avro/Protobuf for type-safe evolution.
OOP & Design Patterns 2
▼
Understands the fundamentals of Design Patterns at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Has deep expertise in design patterns for Scala: designs effect-based architectures with ZIO/Cats Effect, implements type-level programming patterns for compile-time safety, optimizes functional patterns for JVM performance. Mentors team on FP design patterns for production Scala systems.
Implements functional design patterns in Scala team codebase: Tagless Final, Free Monad, Reader/Writer for dependency injection. Conducts architectural reviews emphasizing typeclass patterns from Cats and ZIO for ensuring code composability and testability.
Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Applies OOP/SOLID combined with functional design in Scala: type class pattern for ad-hoc polymorphism, cake pattern/ZIO layers for dependency injection, sealed trait hierarchies for exhaustive pattern matching. Designs architectures balancing OOP encapsulation with functional purity using effect systems.
Shapes team standards for combining OOP and FP in Scala: using sealed trait hierarchies, case classes for domain models, trait mixins for composition. Reviews module architecture for SOLID compliance accounting for Scala specifics — ADT, implicits and type classes.
Relational Databases 1
▼
Performs basic SQL queries to PostgreSQL from Scala applications through Doobie or Slick: SELECT, INSERT, UPDATE with parameterized queries. Understands PostgreSQL data types, works with migrations through Flyway and can read simple query execution plans.
Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses Slick/Doobie effectively.
Optimizes PostgreSQL usage in Scala services: HikariCP connection pool configuration, JSONB fields, window functions and CTEs. Designs schemas with partitioning, implements efficient batch operations through Doobie Transactor and monitors slow queries.
Defines PostgreSQL standards for Scala team: choosing between Doobie, Slick and Quill, migration writing rules, table partitioning strategies. Reviews data architecture, implements read replicas for read scaling and configures logical replication for analytical tasks.
REST API 1
▼
Implements simple REST endpoints in Scala through Play Framework or Akka HTTP: CRUD operations with JSON serialization through Circe, basic input validation. Understands HTTP methods, response codes and RESTful URL structure, follows existing patterns in the project codebase.
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.
Designs evolvable REST APIs for Scala microservices: versioning strategies, backwards compatibility, rate limiting through Akka HTTP. Implements OpenAPI specifications through Tapir, applies circuit breaker patterns and optimizes serialization for high-load endpoints.
Defines REST API standards for Scala team: endpoint design guidelines, mandatory Tapir usage for type-safe API description, versioning strategy. Reviews API contracts for domain model alignment, ensures consistency across microservices.
Stream Processing 1
▼
Understands Kafka Streams topology basics: sources, processors, and sinks. Reads existing stream processing code and follows established patterns for stateless transformations.
Implements stateful stream processing with Kafka Streams using windowed aggregations and joins in Scala. Tunes RocksDB state stores for throughput and manages changelog topics.
Designs distributed stream processing architectures with Kafka Streams for Scala microservices. Implements custom SerDes, interactive queries for state store access, and partition-level parallelism strategies.
Defines stream processing standards for Scala team: choosing between Kafka Streams, FS2-Kafka and Akka Streams for specific use cases. Reviews stream processor topologies, implements exactly-once processing patterns, configures consumer lag and stream processing latency monitoring.
System Design 1
▼
Understands basic system design principles: client-server architecture, REST API, basic data flow in Scala application. Knows stateless/stateful service concepts, reads architectural diagrams and participates in simple component design discussions.
Designs Scala system components: microservice decomposition, choosing between synchronous (gRPC) and asynchronous (Kafka) communication. Understands CAP theorem in Akka Cluster context, applies retry/circuit breaker patterns and designs API contracts for inter-service communication.
Designs Scala systems end-to-end: distributed systems on Akka Cluster, Event Sourcing with Akka Persistence, CQRS for scaling. Makes trade-off decisions on consistency vs availability, designs fault-tolerant architectures with graceful degradation and self-healing.
Defines architectural standards for Scala team: Architecture Decision Records, service design patterns, migration strategies. Reviews system design for non-functional requirements compliance, conducts design review sessions and creates technical architecture documentation.
Test Strategy 1
▼
Understands the fundamentals of property-based testing with ScalaCheck. Writes basic generators and properties for Scala data types. Follows team practices for verifying algebraic laws and Cats-effect type class instances.
Applies property-based testing in Scala through ScalaCheck: defines properties for pure functions, generates test data through Arbitrary and Gen. Integrates ScalaCheck with ScalaTest/MUnit, understands shrinking concept for minimizing failing cases in domain models.
Designs property-based testing strategy for Scala services: custom generators for domain types, stateful property testing for Akka Actors. Implements combinatorial generators through ScalaCheck or ZIO Test Gen, tests business logic invariants and Protobuf message serialization/deserialization.
Defines property-based testing standards for Scala team: mandatory property tests for codecs and serialization, shared generator library. Reviews property quality, implements ZIO Test for effect-based property testing and integrates generators with inter-service contract tests.
Type Systems 2
▼
Understands the fundamentals of Generics & Parametric Polymorphism at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Architects type-level computations in Scala: implements higher-kinded types (F[_]) for tagless final and free monad patterns. Designs generic type class hierarchies (Functor, Monad, Traverse) with lawful instances and automatic derivation. Applies path-dependent types and type projections for advanced generic abstractions, uses match types (Scala 3) and type lambdas for compile-time type transformations. Mentors team on variance rules and type inference debugging.
Defines Generics and Parametric Polymorphism usage standards at team/product level. Conducts architectural reviews. Creates best practices and training materials for the entire team.
Understands the fundamentals of Type Safety & Type Systems at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.
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.
Has deep expertise in Scala type system — designs type-safe DSLs with dependent types, match types, and opaque type aliases. Architects effect-based systems using ZIO/Cats Effect with type-level error handling and resource safety. Mentors team on advanced type class derivation, implicit resolution, and balancing type-level sophistication with codebase accessibility.
Establishes team standards for Scala type system usage: refined types for validation, phantom types for states, opaque types for domain primitives. Reviews type-level programming correctness, ensures balance between type safety and code readability.
Web Frameworks 1
▼
Uses Scala Frameworks at a basic level in Play/http4s. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements tasks with Scala Frameworks in Play/http4s. Understands internals and optimizes performance. Writes tests with ScalaTest/MUnit.
Designs solutions based on Scala Frameworks for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.
Defines architectural decisions for Scala Frameworks at product level. Establishes standards. Conducts design reviews and defines technical roadmap.