Algorithms & Data Structures 2
▼
Understands basic algorithmic concepts in Java: simple Stream operations, basic sorting and searching in collections, loop-based algorithms for data processing. Follows team guidance on algorithm selection and applies standard Java Collections Framework operations.
Independently applies algorithmic thinking in Java: selects efficient Stream operations for data processing, understands parallel algorithm patterns with ForkJoinPool, evaluates collection algorithm trade-offs. Analyzes computational complexity of hot code paths in Spring services.
Applies algorithmic expertise in Java development: stream pipeline optimization for bulk data processing, parallel algorithm design with ForkJoinPool, efficient search algorithms for in-memory data stores. Designs garbage-collection-friendly algorithms minimizing object churn in latency-sensitive services.
Sets performance budgets for Java services. Conducts code reviews focused on algorithmic complexity and memory consumption. Implements automatic degradation monitoring via JMH benchmarks in CI.
Understands basic Java collection types: ArrayList, HashMap, HashSet for common operations. Follows team conventions for entity classes and DTO structures. Applies simple data structures for CRUD operations and Spring controller request/response handling.
Independently selects appropriate data structures in Java: ArrayList vs LinkedList for sequential data, HashMap vs TreeMap for keyed lookups, concurrent collections for multi-threaded scenarios. Understands trade-offs between collection implementations for different access and mutation patterns.
Selects optimal data structures for Java applications: ConcurrentHashMap for thread-safe caching, TreeMap for ordered data access, ArrayDeque for high-performance queues. Optimizes collection usage considering JVM memory overhead and GC impact. Designs custom data structures with proper equals/hashCode contracts and serialization support.
Defines data handling standards for the Java team: immutable collections, record classes, sealed interfaces. Reviews data structure choices in context of concurrency and memory footprint.
API Management 2
▼
Documents API via SpringDoc/OpenAPI annotations: @Operation, @ApiResponse, @Schema. Describes parameters, request bodies, and response examples. Keeps Swagger UI up to date.
Designs API documentation in Java projects: spec-first via OpenAPI YAML, code generation via openapi-generator. Documents error codes, authentication flows, rate limits. Automates freshness checks via Spring REST Docs.
Builds documentation pipeline: auto-generation from code + manual guides, versioned docs, changelog between API versions. Integrates Spring REST Docs with Asciidoctor for production-ready documentation.
Defines API documentation standards for the team: mandatory sections, examples, changelog format. Implements docs-as-code approach. Ensures developer experience through developer portal.
Understands why API versioning is needed. Works with different versions via URL path (/v1, /v2). Maintains backward compatibility when adding new fields. Knows semantic versioning.
Implements API versioning in Spring: URL-based, header-based, media type versioning. Supports multiple versions simultaneously via abstractions. Plans deprecation lifecycle. Automates compatibility checks.
Designs versioning strategy for Java platform: consumer-driven contracts via Pact, schema evolution via Protocol Buffers. Automates breaking change detection in CI. Manages migration path between versions.
Defines product versioning policy: deprecation strategy, minimum support window, communication plan for breaking changes. Implements automated compatibility testing in pipeline.
Caching 2
▼
Understands why caching is needed in Java applications. Applies Spring Cache abstraction: @Cacheable for read-heavy operations. Invalidates cache on data updates. Knows the difference between local and distributed cache.
Designs multi-level caching: Caffeine (L1) + Redis (L2) via Spring Cache. Implements cache-aside pattern with DB fallback. Prevents cache stampede via distributed locks. Monitors cache hit ratio.
Designs caching strategies for high-load Java services: near-cache via Hazelcast/Coherence, write-behind for batch persistence, pre-warming on deployments. Optimizes serialization overhead.
Defines team caching standards: what data to cache, TTL policies, invalidation strategies. Implements cache performance metrics and alerting. Balances consistency and latency.
Uses Redis via Spring Data Redis for caching: @Cacheable, @CacheEvict, @CachePut. Works with strings, hashes, lists. Understands TTL and eviction policies. Configures RedisTemplate with Jackson serializer.
Designs caching strategies for Java services: cache-aside, write-through, cache stampede protection via Redisson locks. Uses Redis Pub/Sub for invalidation. Configures Lettuce connection pool and sentinel for HA.
Designs distributed caching: Redis Cluster for horizontal scaling, Lua scripts for atomic operations, Redis Streams for event-driven caching. Optimizes memory footprint via compression and hash-pack.
Defines product caching strategy: multi-level cache (L1 Caffeine + L2 Redis), cache warming, invalidation policies. Sets hit ratio metrics and cache latency SLAs.
Clean Code & Refactoring 1
▼
Understands basic code quality principles for Java/Spring development. Follows team coding standards and Checkstyle/PMD rules. Writes simple, clean methods following Java naming conventions and Spring patterns. Accepts code review feedback and applies SOLID principles in basic implementations.
Independently applies code quality practices in Java/Spring development. Writes clean code following Spring conventions with proper dependency injection and bean scoping. Understands trade-offs between design pattern usage and code simplicity. Reviews code for exception handling patterns, transaction management, and API design consistency.
Designs code quality standards for Java/Spring projects: Checkstyle/PMD/SpotBugs configurations, architectural decision records, module boundary enforcement. Refactors legacy enterprise code using modern Java patterns (records, sealed classes, virtual threads). Establishes review culture for Spring ecosystem best practices.
Establishes Java code quality standards: SonarQube quality gates, ArchUnit rules, Checkstyle/SpotBugs in CI. Balances development speed and quality. Implements continuous refactoring practices.
Concurrency & Parallelism 2
▼
Understands basic async programming in Java: CompletableFuture basics, @Async annotations in Spring, simple callback patterns. Follows team conventions for async method design and understands basic Future composition.
Independently applies async programming in Java: CompletableFuture composition, reactive streams with Project Reactor/RxJava, virtual threads (Loom). Understands trade-offs between thread-per-request, reactive, and virtual thread models.
Designs async architectures in Java: reactive microservices with Project Reactor, virtual thread migration strategies, async event-driven architectures. Mentors team on choosing between reactive, virtual threads, and CompletableFuture patterns.
Defines async processing strategy: CompletableFuture vs reactive (Project Reactor) vs virtual threads. Implements standards for error handling, backpressure, and async flow monitoring.
Understands basic multithreading in Java: Thread and Runnable basics, synchronized keyword and basic locking, ExecutorService for thread pool management, understanding of volatile and happens-before guarantees. Follows team conventions for concurrent code in Spring applications.
Independently applies multithreading in Java: CompletableFuture for async composition, concurrent collections and atomic operations, ReentrantLock and Condition for advanced synchronization, virtual threads (Project Loom) for lightweight concurrency. Solves typical concurrent programming tasks independently.
Has deep expertise in Java multithreading: designs concurrent systems with virtual threads and structured concurrency, implements lock-free algorithms with AtomicReference and VarHandle, optimizes JVM thread scheduling for high-throughput applications. Mentors team on advanced Java concurrency patterns.
Defines concurrency standards for the Java team: thread pool configurations, lock strategies, concurrent data structures. Implements multithreaded code testing practices. Conducts reviews for race conditions.
Data Modeling 2
▼
Designs simple data schemas with JPA: Entity, @OneToMany/@ManyToMany relationships, embedded types. Understands normalization. Uses @Enumerated, @Temporal for column typing.
Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.
Designs domain models for Java services: Aggregates in JPA, Value Objects via @Embeddable, soft deletes via @Where, audit via @EntityListeners. Chooses between JPA and documents (MongoDB) based on context.
Defines data modeling standards: JPA conventions, naming strategy, schema documentation. Reviews models for DDD compliance and performance implications.
Writes migrations via Flyway/Liquibase: CREATE TABLE, ALTER TABLE, adding indexes and constraints. Understands migration versioning and rollback. Tests migrations on dev environment.
Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.
Designs safe production migrations: online schema changes via pt-online-schema-change/gh-ost, zero-downtime column renames, backfill via batch updates. Automates migrations in CI/CD pipeline.
Defines team migration standards: Flyway vs Liquibase, schema change review process, rollback strategies. Implements automatic migration testing on production data copies.
Database Optimization 3
▼
Creates indexes to speed up frequent queries. Understands the difference between B-tree, hash, and GIN indexes. Uses EXPLAIN to verify index usage. Knows about index impact on write speed.
Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.
Designs indexing strategy for Java services: partial indexes, covering indexes, GIN for JSONB. Analyzes index bloat and automates REINDEX. Configures monitoring of unused indexes via pg_stat_user_indexes.
Defines indexing standards for the team: mandatory EXPLAIN in PRs, index naming conventions, migration review rules. Implements automatic missing index detection.
Understands N+1 problem in JPA and solves via fetch join / @EntityGraph. Uses EXPLAIN ANALYZE for query analysis. Avoids SELECT * and loading unnecessary associations.
Independently designs schemas and optimizes queries. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.
Optimizes SQL in Java services: rewrites JPA queries to native SQL/jOOQ for complex analytical operations. Configures Hibernate batch fetch size, second-level cache. Profiles via p6spy and slow query log.
Defines query performance standards for the team: execution time budgets, mandatory profiling for new endpoints. Implements automatic slow query monitoring in production.
Understands ACID properties and isolation levels. Uses @Transactional in Spring for transaction management. Handles deadlocks and optimistic locking via @Version. Knows the difference between read committed and repeatable read.
Independently designs schemas and optimizes queries with transactions and concurrency. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.
Designs transaction model for Java services: distributed transactions via Saga, eventual consistency via events, compensating transactions. Optimizes transaction scope to minimize lock contention.
Defines team transaction standards: @Transactional usage rules, default isolation levels, conflict handling strategies. Conducts transaction boundary reviews.
Domain-Driven Design 1
▼
Understands DDD tactical patterns in Java/Spring: Entity, Value Object, Repository with Spring Data JPA. Applies Ubiquitous Language using domain-driven package structure. Implements Repository pattern with JPA repositories and custom queries.
Applies DDD tactical patterns in Java/Spring: Aggregates with JPA entity lifecycle, Domain Events via Spring Events/Axon, Specification pattern. Designs aggregate roots with optimistic locking and event-driven side effects. Implements rich domain models avoiding anemic anti-pattern.
Designs DDD architecture for Java/Spring domains with Bounded Contexts, Context Maps, and Anti-corruption Layers for legacy integration. Trains team on Axon Framework, event sourcing patterns, and aggregate design. Balances DDD complexity with delivery pragmatism.
GraphQL 1
▼
Creates simple GraphQL schemas via Spring for GraphQL: types, queries, mutations. Implements resolvers with @QueryMapping/@MutationMapping. Understands the difference between REST and GraphQL. Tests via GraphiQL.
Designs GraphQL API for Java services: custom scalars, input types, enum mapping. Implements DataLoader to solve N+1. Configures pagination via Relay Connection spec. Handles errors through GraphQL error extensions.
Designs GraphQL architecture: federation for microservices, subscriptions via WebSocket, caching strategies. Optimizes query complexity and depth limiting. Integrates with Spring Security for field-level authorization.
Defines product GraphQL strategy: schema conventions, federation architecture, performance budgets. Implements schema registry and breaking change detection in CI.
Message Queues & Event Streaming 2
▼
Understands Kafka fundamentals for Java services: Spring Kafka producer/consumer setup, topic/partition concepts, and message serialization with Avro/JSON. Follows team practices for consumer group configuration and basic error handling in message processing.
Designs Kafka flows for Java services: partition key selection for ordering, consumer concurrency configuration, exactly-once semantics via transactional producer. Handles poison pills through DLT. Configures Schema Registry for Avro/Protobuf.
Designs event-driven architecture on Kafka: event sourcing, saga pattern for distributed transactions, Kafka Streams for stream processing. Optimizes throughput: batch size, compression, partition count. Ensures exactly-once between services.
Defines product Kafka strategy: topic naming conventions, schema evolution policy, retention settings. Implements event-driven communication standards. Plans cluster capacity and monitoring.
Works with RabbitMQ via Spring AMQP: sends messages to exchange, listens to queues via @RabbitListener. Understands exchange types (direct, topic, fanout). Handles errors through retry and DLQ.
Designs RabbitMQ topology for Java services: exchange-queue bindings, routing keys, priority queues. Configures publisher confirms and consumer acknowledgment. Implements retry with exponential backoff. Monitors via Management Plugin.
Designs reliable messaging architecture: federation for geo-distributed systems, shovel for cross-cluster replication, quorum queues for consistency. Optimizes throughput and ensures message ordering.
Defines product messaging strategy: choosing between RabbitMQ and Kafka, message format standards, routing conventions. Implements monitoring and alerting for queues.
Microservices Patterns 1
▼
Decomposes Java monolith into Spring Boot microservices: extracts bounded contexts into separate services, implements anti-corruption layer with Spring Integration. Uses Spring Cloud Gateway for Strangler Fig migration. Manages distributed transactions with Saga pattern via Axon Framework or custom orchestrator.
Architects Java microservices decomposition at scale: designs bounded context boundaries with CQRS and event sourcing (Axon, Eventuate). Implements service mesh patterns (Istio with Spring Boot). Designs database-per-service with distributed Saga orchestration. Evaluates decomposition granularity trade-offs: nano-services vs coarse-grained services for throughput and latency requirements.
Defines Java microservices decomposition standards across the organization: establishes reference architectures with Axon/Eventuate for CQRS and event sourcing. Drives service mesh governance and platform-level Saga orchestration. Designs cross-team API contract management with AsyncAPI, OpenAPI, and consumer-driven contract testing. Reviews decomposition granularity decisions. Mentors senior engineers on DDD strategic patterns and avoiding distributed monolith traps.
Networking 1
▼
Understands TCP/IP, DNS, HTTP/HTTPS in Java application context. Configures Spring Boot: server.port, ssl, compression. Diagnoses connection issues. Understands CORS and configures via WebMvcConfigurer.
Designs network architecture for Java services: load balancing, reverse proxy (nginx/Envoy), service discovery (Eureka/Consul). Configures HTTP client timeouts and connection pooling in RestTemplate/WebClient.
Designs Java platform network infrastructure: service mesh for inter-service communication, mTLS, gRPC for low-latency. Optimizes network I/O via Netty and Project Reactor. Configures DNS-based routing.
OOP & Design Patterns 2
▼
Understands basic design patterns in Java: Singleton, Factory Method, Builder pattern, Observer in event handling, dependency injection with Spring IoC container. Follows team conventions for pattern usage in Spring Boot applications.
Independently applies design patterns in Java: strategy with Spring profiles, template method for service workflows, decorator for stream processing, observer with Spring Events. Understands trade-offs between design patterns and framework conventions in Spring Boot.
Has deep expertise in design patterns for Java: designs domain-driven architectures with DDD tactical patterns, implements hexagonal architecture for testable business logic, optimizes pattern usage for JVM performance. Mentors team on enterprise Java patterns for microservice architectures.
Establishes architectural standards for the Java team based on patterns. Defines Spring configurations and conventions for the project. Conducts architectural reviews focused on GoF and enterprise patterns.
Understands basic OOP concepts in Java: classes, interfaces, abstract classes, encapsulation. Applies simple SOLID principles following Spring project structure. Follows team patterns for service/controller/repository class design and Spring DI annotations.
Independently applies OOP/SOLID in Java/Spring: proper interface-based service contracts, Spring DI for dependency inversion, abstract classes for shared domain behavior. Understands trade-offs between inheritance hierarchies and composition patterns in enterprise Java architecture.
Applies OOP/SOLID in Java/Spring architecture: proper Spring Bean lifecycle management with DI, interface-based service contracts, template method for reusable business logic. Designs clean hexagonal/onion architectures using Java's sealed interfaces, records for value objects, and module system for boundary enforcement.
Defines OOP standards for the Java team: coding guidelines, ADRs, records and sealed classes usage. Trains developers on SOLID and DDD modeling. Conducts design reviews for new modules.
Relational Databases 2
▼
Writes SQL queries for CRUD operations via JPA/Hibernate. Creates tables, indexes, foreign keys. Understands normalization up to 3NF. Uses MySQL Workbench for data analysis.
Independently designs schemas and optimizes queries with MySQL / MariaDB. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.
Designs MySQL architecture for Java services: partitioning, read replicas via Spring DataSource routing, connection pooling via HikariCP. Optimizes JPA queries: batch inserts, fetch strategies, native queries for analytics.
Defines MySQL standards for the team: naming conventions, migration workflow, query performance budgets. Conducts schema and query reviews. Plans capacity and scaling strategy.
Works with PostgreSQL via JPA/Hibernate: entity mapping, JPQL queries, native queries. Uses pgAdmin for data and schema analysis. Understands PostgreSQL data types: UUID, JSONB, arrays.
Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.
Uses advanced PostgreSQL features in Java services: partitioning, materialized views, full-text search via tsvector. Configures connection pooling (PgBouncer + HikariCP). Optimizes ORM: batch operations, query hints, statistics.
Defines PostgreSQL standards for the team: extension policy, schema review process, monitoring via pg_stat_statements. Chooses between JPA native queries and jOOQ for complex queries.
REST API 1
▼
Creates REST endpoints via Spring MVC: @RestController, @GetMapping/@PostMapping, @RequestBody/@PathVariable. Returns proper HTTP statuses. Validates input via @Valid and Bean Validation.
Designs RESTful API following best practices: HATEOAS, content negotiation, pagination via Pageable. Implements versioning through URL path or headers. Documents via SpringDoc/Swagger. Handles errors through @ControllerAdvice.
Designs API architecture for Java platform: API Gateway (Spring Cloud Gateway), rate limiting, circuit breaker via Resilience4j. Defines contracts through OpenAPI spec-first approach. Optimizes latency via async endpoints and reactive streams.
Defines product API standards: naming conventions, error format, pagination strategy, versioning policy. Implements contract-first development and automated contract testing. Conducts API design reviews.
Search Engines 1
▼
Uses Elasticsearch / OpenSearch at basic level. Performs simple tasks using ready templates. Understands basic concepts and follows team practices.
Independently implements Elasticsearch integration in Java with Spring Data Elasticsearch/RestHighLevelClient. Designs index mappings, builds complex queries with QueryBuilders, and implements bulk indexing with refresh strategies.
Designs search solutions for Java platform: custom analyzers for Russian/English, nested/parent-child documents, aggregations for analytics. Integrates via Spring Data Elasticsearch. Optimizes mapping and indexing pipeline.
Defines full-text search strategy: Elasticsearch for search vs SQL for filtering, index lifecycle management, capacity planning. Implements monitoring via Kibana and cluster health alerting.
Type Systems 2
▼
Understands Java generics fundamentals: declares generic classes and methods with type parameters, uses bounded type parameters (extends/super). Aware of type erasure and its implications — cannot instantiate T or use instanceof with generic types. Correctly applies generic collections (List<String>, Map<K,V>) and avoids raw types in new code.
Applies advanced Java generics: uses wildcard types (? extends T, ? super T) following PECS principle (Producer Extends, Consumer Super). Implements generic utility methods with recursive type bounds (<T extends Comparable<T>>). Understands bridge methods generated by type erasure, handles generic array creation limitations, and applies @SafeVarargs for heap pollution prevention in variadic generic methods.
Designs sophisticated generic APIs in Java: implements type-safe heterogeneous containers (Class<T> as key), builds generic fluent DSLs with phantom type parameters for compile-time state validation. Applies Typesafe Heterogeneous Container pattern, designs generic annotation processors for compile-time validation. Navigates type erasure edge cases in serialization frameworks (Jackson, Gson TypeToken), implements generic type resolution via reflection (ParameterizedType, TypeVariable).
Defines generics usage standards for the Java team: bounded type parameters, wildcard conventions, type-safe builders. Reviews API design focused on type safety and ergonomics.
Understands basics of Java type system — generics, bounded type parameters, and Optional for null safety. Follows team conventions for type-safe collections, enum patterns, and interface-based dependency injection with proper type hierarchies.
Independently applies Java type system features — wildcard generics, sealed classes for ADTs, and type-safe builder patterns. Understands trade-offs between type erasure and reified generics, raw types vs parametric polymorphism. Applies type-safe patterns with records, pattern matching, and annotation processing in code reviews.
Has deep expertise in Java type system — designs domain models leveraging sealed interfaces, pattern matching exhaustiveness, and generic type witnesses for type-safe APIs. Architects type-safe annotation-driven frameworks and compile-time validation processors. Mentors team on advanced generics, type token patterns, and effective use of sealed hierarchies for domain modeling.
Defines Java project typing strategy: NullAway/Checker Framework, sealed interfaces for domain modeling, record classes for DTOs. Implements strict null checks in CI pipeline.
Web Frameworks 1
▼
Uses Java Spring Ecosystem at basic level. Performs simple tasks using ready templates. Understands basic concepts and follows team practices.
Independently implements tasks with Java Spring Ecosystem. Understands internals and optimizes performance. Writes tests.
Designs solutions based on Java Spring Ecosystem for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.
Defines Java Spring Ecosystem architectural decisions at product level. Establishes standards. Conducts design reviews and defines technical roadmap.