Grade Calculator — DevLevelUp

Select a role to assess

Rate your skill proficiency — the system will calculate your recommended grade

Role

Skills Self-Assessment

Role: Backend Developer (Scala)

Assessed: 0 Total: 0

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.

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.

Shapes algorithm optimization strategy at platform level, makes architectural decisions on data structure selection for high-load Scala systems. Defines acceptable complexity thresholds for distributed computing in Spark and stream processing in Kafka Streams.

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.

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.

Makes strategic decisions on data structure selection for platform components: off-heap storage, specialized collections for Spark RDD and Dataset API. Evaluates trade-offs between immutability and performance at the overall system architecture level.

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.

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.

Shapes API documentation strategy at organizational level: unified developer portal for all Scala services, API changelog standards, API Governance integration. Defines cross-team API contract review processes, introduces API catalogue for service discoverability.

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.

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.

Shapes API versioning policy for the entire Scala platform: semantic versioning standards for gRPC and REST, multi-version support strategy, sunset processes. Defines API Gateway architecture for version routing, integration with consumer-driven contract testing through Pact.

Caching 2

▼

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.

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.

Makes strategic decisions on caching infrastructure for the entire platform: choosing between Redis Cluster and Redis Sentinel, sharding policies, cost evaluation through FinOps. Defines edge caching architecture for globally distributed Scala services with sub-millisecond latency requirements.

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.

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.

Shapes code quality culture at organizational level: standards for Scala projects, technical debt metrics, legacy codebase refactoring strategy. Defines balance between type system strictness and development velocity, introduces architectural fitness functions for system evolution control.

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.

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.

Makes strategic decisions on Scala platform concurrency model: ZIO Runtime vs Cats Effect IO vs Akka Actor Model. Defines backpressure handling architecture in streaming systems, designs fault tolerance strategies across the entire distributed infrastructure.

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.

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.

Designs concurrency management strategy for the entire Scala platform: JVM thread scheduling configuration, choosing between green threads (Project Loom) and fiber-based model of ZIO/Cats Effect. Makes decisions on scaling multithreaded systems at cluster and infrastructure level.

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.

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.

Makes strategic decisions on platform data architecture: choosing between relational and event-driven models, Schema Registry standards for inter-service communication. Defines Data Mesh approach for Scala microservices, designs data models considering scalability, compliance and analytics requirements.

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.

Defines product-level data strategy. Establishes Database Migration standards. Conducts data schema and scaling strategy reviews.

Shapes database schema management strategy for the entire Scala platform: zero-downtime migration standards through Flyway, backward compatibility policies, emergency rollback processes. Defines schema evolution approaches in multi-service environments — shared database vs database-per-service for Scala microservices.

Database Optimization 3

▼

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.

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.

Shapes indexing strategy at platform level: balancing read speed and write cost across all Scala services. Makes decisions on covering indexes, BRIN for time-series data, defines index analysis automation through pg_stat_user_indexes.

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.

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.

Defines database performance strategy for the entire platform: query performance standards, latency SLA, automated query regression testing. Makes decisions on data architecture — sharding, CQRS, full-text search through Elasticsearch integration with Scala services.

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.

Defines product-level data strategy. Establishes Transactions and Concurrency standards. Conducts data schema and scaling strategy reviews.

Defines transaction management strategy at Scala platform level: Saga pattern standards for distributed transactions in Akka clusters, isolation policies for OLTP/OLAP workloads. Makes decisions on eventual consistency vs strong consistency for different domains, designs compensation mechanisms.

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.

Defines Functional Programming Principles usage standards at team/product level. Conducts architectural reviews. Creates best practices and training materials for the entire team.

Defines organizational FP strategy for Scala: selects effect systems (Cats Effect vs ZIO), establishes standards for functional domain modeling, drives adoption of property-based testing. Shapes technical vision for migrating legacy OOP codebases toward functional architectures.

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.

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.

Shapes the organization's functional programming and immutability strategy across Scala and JVM ecosystems. Drives innovation in immutable architecture patterns for distributed systems including CRDT-based state synchronization, append-only data architectures, and zero-copy serialization of immutable structures. Influences the Scala community through contributions to typelevel ecosystem and functional programming best practices.

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.

Defines Monads and Functors usage standards at team/product level. Conducts architectural reviews. Creates best practices and training materials for the entire team.

Defines Monads and Functors strategy at organizational level. Makes decisions on approaches and tools. Mentors lead developers and shapes technical vision.

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.

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.

Shapes inter-service communication strategy for Scala platform: gRPC as internal communication standard, Service Mesh integration through Envoy/Istio. Defines API Gateway architecture for gRPC/REST translation, Protobuf schema evolution policies and RPC call observability standards.

Message Queues & Event Streaming 1

▼

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.

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.

Shapes event architecture strategy for the entire Scala platform: Event Sourcing standards through Kafka, schema evolution policies, multi-datacenter replication. Makes Kafka cluster scaling decisions, evaluates alternatives (Pulsar, Redpanda) and defines SLA for stream data processing.

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.

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.

Makes strategic data storage architecture decisions: PostgreSQL as primary OLTP database for Scala platform, Citus integration for horizontal scaling, multi-region deployment strategy. Defines backup policies, DR plans and evaluates transition to managed solutions (RDS, Cloud SQL).

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.

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.

Shapes API strategy for the entire Scala platform: REST vs gRPC vs GraphQL standards for different scenarios, API Gateway architecture, API-first development approach. Defines backward compatibility policies, deprecation lifecycle and SLA for public and internal organizational APIs.

System Design 1

▼

Understands basic High Load Architecture concepts. Follows team architectural decisions. Understands main patterns.

Designs components of high-load Scala services: non-blocking processing through ZIO/Cats Effect, connection pooling through HikariCP, basic caching. Understands horizontal scaling principles, implements async request processing through Akka HTTP and applies backpressure in Akka Streams.

Defines high-load Scala service architecture for the team: scaling standards, capacity planning, degradation strategies. Reviews architecture for peak load handling capability, implements load testing through Gatling, configures auto-scaling policies and circuit breaker patterns.

Shapes scaling strategy for Scala platform: architecture for millions of RPS, multi-region deployment with geo-routing, global load balancing. Makes decisions on Akka Cluster vs serverless architecture for different workloads, defines SLA/SLO and infrastructure budgets through FinOps.

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.

Defines Generics and Parametric Polymorphism usage standards at team/product level. Conducts architectural reviews. Creates best practices and training materials for the entire team.

Defines organization-wide generic programming standards in Scala: establishes type class encoding conventions (Scala 2 implicits vs Scala 3 given/using), designs generic effect system abstractions (Cats Effect, ZIO) with principled type parameter hierarchies. Drives adoption of compile-time type-level programming (singleton types, type-level natural numbers, compile-time proofs) for domain invariant enforcement. Evaluates and shapes Scala language evolution proposals related to type system expressiveness — opaque types, match types, polymorphic function types.

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.

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.

Defines type safety strategy for Scala platform: leveraging Scala 3 match types, inline/given, compile-time type-level checks. Designs domain DSLs with correctness guarantees through the type system, makes decisions on applying dependent types and type-level computations.

Web Frameworks 1

▼

Additional skills (optional) 42

These skills do not affect the main grade but show the breadth of your profile.

AI Coding Assistants

▼

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.

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.

Alerting & On-Call

▼

API Management

▼

Understands rate limiting in Scala: knows Akka HTTP throttle directive, understands how Akka Streams backpressure provides natural flow control. Can apply basic rate limiter to HTTP endpoint.

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.

Standardizes rate limiting in Scala ecosystem: creates library with functional rate limiter API (tagless final), designs configuration-driven limiting through Lightbend Config, defines observability patterns. Trains teams on functional approaches to rate limiting.

API Protocols

▼

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.

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

▼

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.

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.

Follows basic secure coding principles in Scala: doesn't store secrets in code, uses parameterized queries, handles errors through Try/Either. Applies Scala type-safe constructs to prevent runtime errors, understands least privilege principle.

Applies secure coding practices in Scala: refined types for validation, opaque types for secrets, secure logging without PII. Uses cats-effect Resource for safe resource management, implements proper error handling without leaking internal details in API responses.

Defines secure coding standards for Scala team: secure code review checklists, mandatory type-safe patterns, unsafe API prohibition. Implements automated security linting through WartRemover with custom rules, conducts security training and builds safe utilities library.

Authentication & Authorization

▼

Understands basic JWT and OAuth 2.0 concepts in Scala application context: JWT token structure, Bearer authentication in Akka HTTP/Play. Uses ready-made libraries for token validation, can extract claims and pass auth context through service requests.

Implements authentication and authorization in Scala services: JWT generation and validation through jwt-scala, OAuth 2.0 Authorization Code Flow through Silhouette/PAC4J. Configures middleware for user extraction from token, implements role-based access control through custom Akka HTTP directives.

Defines authentication standards for Scala team: unified auth middleware, signing key secret management strategy, key rotation procedures. Reviews authorization architecture, implements ABAC/RBAC through policy engine (OPA), configures centralized auth logging for auditing.

Shapes Identity & Access Management strategy for Scala platform: IdP selection (Keycloak, Auth0, Okta), zero-trust authentication architecture. Defines OAuth 2.0/OIDC standards for all services, compliance policies (SOC 2, GDPR), corporate SSO integration and federation.

CI/CD

▼

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.

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.

Cloud Providers

▼

Familiar with basic AWS services for Scala development: EC2, RDS (PostgreSQL), S3 for file storage. Understands IAM roles for resource access, can deploy Scala application in container through ECS or use Elastic Beanstalk for simple deployment.

Uses AWS services for Scala microservices: ECS/EKS for orchestration, RDS with read replicas, ElastiCache Redis, SQS/SNS for async communication. Configures AWS SDK for Scala through Cats Effect integration, works with CloudWatch for JVM metrics and log monitoring.

Defines AWS architecture for Scala team: service usage standards, Landing Zone, security baseline. Reviews infrastructure decisions, implements GitOps through ArgoCD, configures multi-account strategy and FinOps practices with Cost Explorer for budget optimization.

Code Review

▼

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.

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.

Containerization

▼

Builds Docker images for Scala applications through sbt-native-packager or Dockerfile: basic JVM configuration, copying fat JAR. Runs containers locally through docker-compose for development, understands basics of volumes and networking for connecting to PostgreSQL and Redis.

Optimizes Docker images for Scala services: multi-stage build with sbt, GraalVM Native Image for size reduction, JVM flag configuration for container environment. Configures docker-compose for full local environment with Kafka, PostgreSQL and monitoring.

Defines containerization standards for Scala team: base images, JVM configuration for different workloads, security hardening. Implements build automation through sbt plugins, configures image registry and tagging policies for GitOps deployment in Kubernetes.

Database Optimization

▼

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.

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 sharding in Scala ecosystem: knows how Akka Cluster Sharding works for in-memory data, distinguishes database sharding and actor sharding. Can work with Slick/Quill with multiple database configurations.

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.

Standardizes sharding in Scala ecosystem: defines when to use Akka Cluster Sharding vs database-native sharding, designs data placement strategy for distributed Scala systems. Creates abstractions for transparent sharding with type-safe shard key definitions.

Distributed Tracing

▼

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.

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.

E2E Testing

▼

Event-Driven Architecture

▼

Understands CQRS in Scala ecosystem: knows Akka Persistence for event sourcing, distinguishes Command and Event in typed actor model. Can work with existing Akka-based CQRS code at the level of simple changes.

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.

Standardizes CQRS in Scala ecosystem: chooses between Akka Persistence and ZIO-based solutions (zio-entity), designs multi-bounded context architecture, creates abstractions for testable CQRS. Defines migration strategy from Akka Classic to Akka Typed for CQRS modules.

Understands event-driven architecture in Scala/Akka ecosystem context. Knows Actor Model, Akka actors as message processing method, distinguishes tell and ask patterns. Understands Kafka's role in Scala projects.

Develops event-driven Scala services with Akka Streams, Alpakka Kafka or FS2/Cats Effect. Implements reactive streams with backpressure, processes events through Akka Persistence for event sourcing. Applies Scala type system for type-safe event contracts.

Defines architecture for event-driven Scala systems: choosing between Akka/Pekko, ZIO, Cats Effect ecosystems for event processing. Designs schema evolution for Avro/Protobuf events, actor systems monitoring. Develops libraries for standardizing event-driven communication.

Git & Workflows

▼

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.

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.

GraphQL

▼

Infrastructure as Code

▼

Integration Testing

▼

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.

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.

Kubernetes & Orchestration

▼

Understands basic Kubernetes concepts for deploying Scala services: Pod, Deployment, Service, ConfigMap. Can read YAML manifests, check pod status through kubectl and view JVM container logs for diagnosing application startup issues.

Configures Kubernetes resources for Scala services: resource limits considering JVM heap, liveness/readiness probes through Akka Management, HPA for autoscaling. Works with Helm charts, configures ConfigMap/Secret for Typesafe Config in containers.

Defines Scala service deployment standards in Kubernetes: Helm chart templates, resource policies, canary/blue-green strategies through ArgoCD. Reviews cluster configuration, implements namespace isolation for teams and configures NetworkPolicy for inter-service security.

Logging

▼

Uses structured logging in Scala through SLF4J/Logback: adds contextual MDC fields, logs errors with stack traces. Understands log levels (DEBUG, INFO, WARN, ERROR), follows existing logging patterns in the Scala project codebase.

Configures structured logging for Scala services: JSON format through Logstage or logback-logstash-encoder, correlation through trace ID. Implements contextual logging in ZIO/Cats Effect through FiberRef/IOLocal, configures appenders for different environments and ELK stack integration.

Defines logging standards for Scala team: mandatory fields, message format, retention and rotation policies. Implements centralized logging through ELK/Loki, configures dashboards for error analysis, defines SLI based on log-based metrics for critical path services.

Memory Management

▼

Message Queues & Event Streaming

▼

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.

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.

Metrics & Monitoring

▼

Understands basic metrics and monitoring concepts for Scala applications: JVM metrics (heap, GC, threads) through Micrometer/Prometheus client. Reads Grafana dashboards, understands main metric values and can find service status information in monitoring.

Configures Prometheus metrics for Scala services: custom counters, histograms for latency, gauges for business metrics through Kamon or ZIO Metrics. Creates Grafana dashboards with RED metrics (Rate, Errors, Duration) for endpoints, configures basic alerts for performance anomalies.

Defines monitoring standards for Scala team: mandatory metrics per service, SLO budgets, on-call procedures. Reviews dashboard and alert quality, implements SRE practices, configures automated runbooks and defines metrics for error budget policy.

Networking

▼

OOP & Design Patterns

▼

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.

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.

Defines architectural patterns for the entire Scala platform: choosing between Tagless Final and ZIO Environment, Effect system usage standards. Establishes guidelines for applying CQRS, Event Sourcing and Saga patterns in distributed Akka systems at organizational level.

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.

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.

Defines domain modeling strategy for Scala platform: balancing OOP inheritance and algebraic data types. Makes decisions on module structure, bounded context boundaries in Akka clusters and ways of expressing business invariants through Scala type system.

Optimization

▼

Profiling

▼

Prompt Engineering

▼

Stream Processing

▼

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.

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.

Shapes stream processing strategy for Scala platform: real-time data pipeline architecture through Kafka Streams/Flink, state management standards. Makes decisions on stream processing cluster scaling, defines SLA for end-to-end latency and integration with Data Mesh approach.

System Design

▼

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.

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

▼

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.

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.

Shapes property-based testing culture at organizational level: standards for Scala projects, shared generator libraries for domain types. Defines integration of property-testing with formal verification approaches, introduces mutation testing through Stryker4s for evaluating test property effectiveness.

Unit Testing

▼

Understands basic unit testing in Scala: ScalaTest/MUnit test structure, assertion styles (should/must), simple fixture setup. Follows team conventions for test organization, sbt test commands, and spec naming patterns.

Writes unit tests for Scala services through ScalaTest or MUnit: tests pure functions, uses mock objects through Mockito-Scala for dependencies. Applies ZIO Test or Cats Effect munit for effect testing, ensures >80% coverage for domain layer business logic.

Defines testing standards for Scala team: mandatory coverage, test naming rules, effectful code testing patterns. Reviews test architecture, implements TDD practices with ZIO Test, configures parallel test execution through sbt to shorten feedback loop.

Web Frameworks

▼