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.

Optimizes connection pooling in Java: configures HikariCP for production (leak detection, connection test, validation timeout), uses Spring Boot Actuator for pool metrics monitoring. Understands statement caching and prepared statement pooling through JDBC driver settings.

Implements CQRS in Java projects: uses Axon Framework for command/query separation, configures event handlers for read model updates, applies Spring Data for read-optimized repositories. Configures sagas for distributed command coordination.

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 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.

Develops gRPC services in Java/Kotlin: implements streaming RPC, configures ServerInterceptor for authentication and tracing, integrates with Spring Boot via grpc-spring-boot-starter. Uses async stub with ListenableFuture for non-blocking calls.

Independently implements tasks with Java Spring Ecosystem. Understands internals and optimizes performance. Writes tests.

Independently designs schemas and optimizes queries with MySQL / MariaDB. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.

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

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.

Implements rate limiting in Java services: uses Bucket4j with Hazelcast/Redis for distributed limiting, configures Resilience4j RateLimiter with custom per-endpoint configuration. Implements tiered rate limiting through Spring interceptors with key extraction from JWT claims.

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 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.

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.

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.

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.

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.

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 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.

Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.

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.

Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.

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.

Independently designs schemas and optimizes queries. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.

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.

Works with messaging in Java ecosystem: uses Spring Kafka for Kafka integration, Spring Cloud Stream for broker abstraction, configures consumer groups and partition assignment. Applies @KafkaListener with concurrency for parallel processing and configures error handler with retry.

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.

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.

Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.

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 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.

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.

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.

Independently designs schemas and optimizes queries with transactions and concurrency. Understands indexing and query execution plans. Uses Hibernate/JPA effectively.

Works with sharding in Java: implements AbstractRoutingDataSource for multi-database routing, uses ShardingSphere for transparent sharding, configures HikariCP connection pools per shard. Applies thread-local context for shard selection in Spring transactions.