Alerting & On-Call 1
▼
Understands what SLA means for Java backend services — knows that 99.9% availability translates to ~8.7 hours allowed downtime per year. Understands why monitoring JVM metrics, response times, and error rates matters for meeting service commitments.
Defines SLIs for Java services — p99 latency from Micrometer metrics, error rate from exception tracking, and JVM health indicators (GC pauses, heap utilization). Configures SLI monitoring with Spring Boot Actuator and Prometheus. Understands error budgets and participates in on-call rotation for Java service reliability.
Defines and implements comprehensive SLOs for Java service portfolios with burn rate alerts correlated to JVM health metrics. Creates SLO dashboards spanning Spring Boot services with distributed tracing through Sleuth/OpenTelemetry. Manages error budgets accounting for GC pauses and thread pool saturation. Conducts post-mortem analysis and designs graceful degradation with Resilience4j patterns.
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.
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.
Defines Java platform performance strategy. Designs solutions for processing millions of events in real-time via Kafka Streams/Flink. Balances throughput, latency and GC pauses at the architecture level.
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.
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.
Designs platform-level data models: Protocol Buffers for inter-service communication, Apache Arrow for analytics, off-heap structures for low-latency services. Defines serialization strategy.
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.
Defines API documentation standards for the team: mandatory sections, examples, changelog format. Implements docs-as-code approach. Ensures developer experience through developer portal.
Shapes documentation platform: unified developer portal for all organizational APIs, automated SDK generation, interactive sandbox. Defines documentation governance.
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.
Defines product versioning policy: deprecation strategy, minimum support window, communication plan for breaking changes. Implements automated compatibility testing in pipeline.
Shapes organizational versioning strategy: unified rules for all APIs, deprecation governance, cross-team migration coordination. Defines SLA for backward compatibility.
Architecture Patterns 1
▼
Follows layered Spring project architecture: controllers contain no business logic, services work through interfaces. Understands Dependency Injection via Spring IoC. Doesn't mix JPA entities with REST DTOs.
Applies Clean Architecture in Java: extracts Use Cases, separates Domain and Infrastructure through Ports & Adapters. Inverts dependencies via Spring interfaces. Writes domain code without Spring/JPA coupling.
Defines architectural standards: module structure, dependency rules, ArchUnit tests for architecture control. Balances architecture cleanliness with delivery speed. Conducts architectural reviews.
Shapes architectural culture: reference architecture for Java services, domain/application/infrastructure layers. Designs shared kernel between services. Determines when clean architecture is justified.
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.
Defines team caching standards: what data to cache, TTL policies, invalidation strategies. Implements cache performance metrics and alerting. Balances consistency and latency.
Shapes enterprise caching strategy for Java platform: CDN + Spring Cache + Hibernate L2 cache layers, cache budgets per service. Defines data freshness requirements for business domains and establishes caching governance across microservices.
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.
Defines product caching strategy: multi-level cache (L1 Caffeine + L2 Redis), cache warming, invalidation policies. Sets hit ratio metrics and cache latency SLAs.
Designs organizational caching platform: shared Redis infrastructure, data partitioning strategy, cross-service cache coherence. Defines governance for cache keys and TTL policies.
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.
Defines async processing strategy: CompletableFuture vs reactive (Project Reactor) vs virtual threads. Implements standards for error handling, backpressure, and async flow monitoring.
Designs Java platform async architecture: event bus (Kafka), message broker (RabbitMQ), stream processing (Kafka Streams/Flink). Makes decisions on transitioning to virtual threads (Loom).
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.
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.
Designs Java platform concurrency model: virtual threads vs reactive, lock-free algorithms for hot path, LMAX Disruptor for ultra-low-latency. Defines scaling strategy under load.
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.
Defines data modeling standards: JPA conventions, naming strategy, schema documentation. Reviews models for DDD compliance and performance implications.
Designs platform data model: bounded context → database mapping, shared entities via domain events, data mesh principles. Defines schema evolution strategy without breaking changes.
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.
Defines team migration standards: Flyway vs Liquibase, schema change review process, rollback strategies. Implements automatic migration testing on production data copies.
Designs platform migration strategy: coordinating schema changes between services, database-per-service migration, data versioning. Defines backward compatibility policy.
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.
Defines indexing standards for the team: mandatory EXPLAIN in PRs, index naming conventions, migration review rules. Implements automatic missing index detection.
Designs platform indexing strategy: cross-service search indexes, index maintenance automation, capacity planning for I/O. Defines trade-offs between read and write performance.
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.
Defines query performance standards for the team: execution time budgets, mandatory profiling for new endpoints. Implements automatic slow query monitoring in production.
Designs platform-level data access strategy: CQRS for read/write model separation, materialized views for analytics, polyglot persistence. Defines SLA for query latency.
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.
Defines team transaction standards: @Transactional usage rules, default isolation levels, conflict handling strategies. Conducts transaction boundary reviews.
Designs platform consistency model: which operations require strong consistency, where eventual is acceptable. Defines distributed transaction strategy between services.
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.
Defines product GraphQL strategy: schema conventions, federation architecture, performance budgets. Implements schema registry and breaking change detection in CI.
Shapes organizational GraphQL platform: supergraph from microservices, schema governance, query analytics. Determines when GraphQL is optimal vs REST vs gRPC.
Infrastructure as Code 1
▼
Understands Infrastructure as Code concept and Terraform basics. Can run terraform plan/apply for Java application infrastructure. Understands state file and backend configuration. Makes changes to existing .tf files for cloud resources used by Java/Spring services.
Writes Terraform configurations for Java service infrastructure: EC2/ECS, RDS, ElastiCache, SQS/SNS. Uses modules for environment consistency across dev/staging/prod. Works with remote state (S3 backend) and state locking. Manages environment-specific variables with tfvars. Imports existing AWS resources into Terraform management.
Designs IaC strategy for Java platform organization. Evaluates Terraform vs Pulumi vs AWS CDK for Java teams. Implements self-service infrastructure via Terraform modules integrated with Backstage developer portal. Designs multi-account landing zones for Java microservices. Drives FinOps through automated cost estimation in CI and resource tagging policies. Manages Terraform at enterprise scale (1000+ resources, multiple teams).
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.
Defines product Kafka strategy: topic naming conventions, schema evolution policy, retention settings. Implements event-driven communication standards. Plans cluster capacity and monitoring.
Designs organizational event-streaming platform: multi-cluster Kafka, cross-datacenter replication (MirrorMaker 2), Kafka Connect for integrations. Defines governance for event contracts and schema registry.
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.
Defines product messaging strategy: choosing between RabbitMQ and Kafka, message format standards, routing conventions. Implements monitoring and alerting for queues.
Designs organizational messaging platform: multi-protocol broker, integration patterns, event-driven communication standards across domains. Defines SLA for message delivery.
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.
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.
Defines Java platform architectural patterns: DDD, Hexagonal Architecture, Event-Driven. Shapes reference architecture on Spring Boot/Spring Cloud. Evaluates approach trade-offs for business context.
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.
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.
Shapes Java platform object model. Determines where OOP is optimal (domain layer) vs functional approach (data pipelines). Designs shared kernel and domain events between services.
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.
Defines MySQL standards for the team: naming conventions, migration workflow, query performance budgets. Conducts schema and query reviews. Plans capacity and scaling strategy.
Designs organizational MySQL data strategy: multi-master replication, sharding (Vitess), migration from monolithic DB to database-per-service. Defines backup and disaster recovery standards.
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.
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.
Designs organizational PostgreSQL platform: logical replication, Citus for distributed queries, TimescaleDB for time-series. Defines migration strategy and backward compatibility.
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.
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.
Designs organizational search platform: multi-tenant indexes, cross-cluster search, ML-based ranking. Defines indexing standards and governance for schema evolution.
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.
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.
Designs platform-level generic frameworks and libraries: type-safe query builders, generic repository patterns, plugin systems. Evaluates type erasure limitations and designs workarounds.
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.
Defines Java project typing strategy: NullAway/Checker Framework, sealed interfaces for domain modeling, record classes for DTOs. Implements strict null checks in CI pipeline.
Shapes Java platform typing standards. Evaluates type system evolution (pattern matching, sealed classes, value types/Valhalla) and plans adoption. Designs type-safe inter-service contracts.
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.
Defines Java Spring Ecosystem architectural decisions at product level. Establishes standards. Conducts design reviews and defines technical roadmap.
Defines Java Spring Ecosystem strategy at company level. Evaluates new technologies and approaches. Shapes enterprise standards and reference architectures.