What a Senior } should know

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

Designs solutions based on Java Spring Ecosystem for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.

Designs messaging architecture for Java microservices: implements transactional outbox via Spring @Transactional + Debezium, configures exactly-once processing in Kafka with transactional producer, designs schema evolution via Confluent Schema Registry. Optimizes consumer throughput via batch listener.

Designs reliable messaging architecture: federation for geo-distributed systems, shovel for cross-cluster replication, quorum queues for consistency. Optimizes throughput and ensures message ordering.

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.

Designs connection management for Java microservices: configures multi-datasource routing via AbstractRoutingDataSource with separate pools for read/write, implements connection warming with initial pool size. Diagnoses connection pool starvation via thread dumps and JMX monitoring.

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.

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.

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.

Designs sharding for Java microservices: configures ShardingSphere with custom sharding algorithms, implements distributed transactions via XA or eventual consistency patterns, designs global tables for reference data. Optimizes cross-shard pagination and sorting.

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.

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.

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.

Designs transaction model for Java services: distributed transactions via Saga, eventual consistency via events, compensating transactions. Optimizes transaction scope to minimize lock contention.

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.

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.

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.

Designs gRPC architecture for Java microservices: configures deadline propagation via Context, implements retry policies with exponential backoff, integrates with Micrometer for metrics and Brave/OpenTelemetry for tracing. Optimizes Netty transport for high loads.

Designs rate limiting for Java microservices: configures Envoy rate limiting service with Java gRPC backend, implements cost-based rate limiting via custom Bucket4j bandwidth definition. Designs graceful degradation with fallback responses on rate limit hit and circuit breaker integration.

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.

Designs AWS architecture for Java platform: EKS, API Gateway + Lambda for serverless endpoints, DynamoDB for high-throughput, Step Functions for workflows. Optimizes costs via Reserved Instances and Spot.

Designs Docker strategy for Java platform: base images, security scanning via Trivy, multi-arch builds. Optimizes startup time via CDS/AppCDS. Configures Buildpacks (Paketo) as alternative to Dockerfile.

Designs K8s architecture for Java platform: namespace-per-team, service mesh (Istio/Linkerd), GitOps via ArgoCD. Optimizes JVM in K8s: vertical pod autoscaling, JVM ergonomics for containers. Configures observability stack.

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.

Designs modular Terraform architecture for Java microservices platform. Creates reusable AWS modules for ECS/EKS, RDS clusters, and messaging infrastructure. Configures Terragrunt for DRY configurations across environments and regions. Implements Sentinel/OPA policies for infrastructure governance. Designs state management strategy. Automates drift detection for production systems.

Designs CI/CD for Java platform: reusable workflows, artifact promotion, canary deployments. Integrates quality gates: SonarQube, dependency check, container scanning. Optimizes build time via incremental compilation.

Designs integration testing strategy: slice tests (@WebMvcTest, @DataJpaTest) vs full integration, contract testing via Pact, performance testing via Gatling. Optimizes CI time: parallel execution, test containers reuse.

Introduces TDD/BDD culture in Java project: outside-in TDD for domain layer, Cucumber + Spring for integration scenarios. Designs testable architecture: ports and adapters, dependency injection. Mentors on testing practices.

Designs Testcontainers testing architecture for Java microservices: custom module creation, shared container pools, and contract testing with containerized services. Optimizes CI/CD test performance with Testcontainers Cloud and parallel execution strategies.

Designs unit testing strategy for Java project: test fixtures via @ExtendWith, shared test utilities, ArchUnit for architectural rules. Optimizes test suite: parallel execution, test categorization. Mentors on testing patterns.

Designs auth architecture for Java platform: centralized identity provider, token exchange between services, fine-grained authorization (OPA/Cedar). Implements multi-tenancy via JWT claims. Ensures token security: rotation, revocation.

Designs Java platform security architecture following OWASP: threat modeling (STRIDE), security testing in CI (OWASP ZAP, Snyk), dependency vulnerability scanning. Implements security-as-code via Spring Security DSL.

Designs secure-by-default architecture: zero-trust between services (mTLS), secrets management via Vault, audit logging. Automates security checks: SAST, DAST, SCA in CI pipeline. Mentors on security.

Maximizes productivity with Copilot: generates complex SQL/JPQL, Kubernetes manifests, Gatling performance tests. Builds workflow where AI accelerates routine while developer focuses on architecture.

Designs Java applications following Hexagonal Architecture: ports for business logic, adapters for JPA/Kafka/REST. Refactors legacy Spring monolith to clean architecture. Defines anti-corruption layers between bounded contexts.

Designs CQRS architecture for Java microservices: chooses between Axon Framework and Eventuate, implements event sourcing with snapshot optimization, configures parallel projections for different read stores (PostgreSQL, Elasticsearch, Redis). Ensures consistency via idempotent event handlers.

Designs Java system architecture: decomposition into microservices, event-driven via Kafka, CQRS for high-read services. Defines API contracts (OpenAPI, gRPC). Conducts capacity planning with JMH benchmarks.

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.

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.

Designs tracing architecture: sampling strategies (head-based, tail-based), trace context propagation via Kafka, custom instrumentation for domain operations. Optimizes overhead and storage costs.

Designs Java platform monitoring: RED metrics for API, JVM dashboards (heap, GC, threads), distributed tracing. Configures SLI/SLO dashboards. Optimizes cardinality. Implements alerting runbooks.

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.

Designs logging strategy for Java platform: correlation ID via Spring Cloud Sleuth/Micrometer Tracing, distributed tracing via OpenTelemetry. Configures log sampling for high-load services.

Conducts architectural review: evaluates system impact, backward compatibility, performance impact. Reviews migrations, API contracts, Spring configurations. Mentors through review.

Defines branching strategy: trunk-based development with feature flags, release branches for multi-version support. Configures git hooks for quality gates (Checkstyle, SpotBugs). Automates semantic versioning.