What a Lead } should know

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 async processing strategy: CompletableFuture vs reactive (Project Reactor) vs virtual threads. Implements standards for error handling, backpressure, and async flow monitoring.

Establishes Java code quality standards: SonarQube quality gates, ArchUnit rules, Checkstyle/SpotBugs in CI. Balances development speed and quality. Implements continuous refactoring practices.

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.

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 generics usage standards for the Java team: bounded type parameters, wildcard conventions, type-safe builders. Reviews API design focused on type safety and ergonomics.

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.

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.

Defines Java project typing strategy: NullAway/Checker Framework, sealed interfaces for domain modeling, record classes for DTOs. Implements strict null checks in CI pipeline.

Defines product Kafka strategy: topic naming conventions, schema evolution policy, retention settings. Implements event-driven communication standards. Plans cluster capacity and monitoring.

Defines team caching standards: what data to cache, TTL policies, invalidation strategies. Implements cache performance metrics and alerting. Balances consistency and latency.

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.

Defines Java Spring Ecosystem architectural decisions at product level. Establishes standards. Conducts design reviews and defines technical roadmap.

Standardizes messaging in the company's Java ecosystem: chooses between Spring Cloud Stream, Axon Framework, Eventuate for event-driven architecture, designs saga orchestration with Temporal or Axon Saga. Implements event store for audit and replay, defines topic governance strategy.

Defines product messaging strategy: choosing between RabbitMQ and Kafka, message format standards, routing conventions. Implements monitoring and alerting for queues.

Defines product caching strategy: multi-level cache (L1 Caffeine + L2 Redis), cache warming, invalidation policies. Sets hit ratio metrics and cache latency SLAs.

Standardizes connection management in Java ecosystem: creates Spring Boot starter for standard pool setup, defines pooling policies for different workload types (OLTP vs OLAP), implements ProxySQL for connection multiplexing. Designs connection budgeting for microservices.

Defines data modeling standards: JPA conventions, naming strategy, schema documentation. Reviews models for DDD compliance and performance implications.

Defines indexing standards for the team: mandatory EXPLAIN in PRs, index naming conventions, migration review rules. Implements automatic missing index detection.

Defines team migration standards: Flyway vs Liquibase, schema change review process, rollback strategies. Implements automatic migration testing on production data copies.

Standardizes sharding in Java ecosystem: chooses between ShardingSphere, Vitess, and application-level sharding, designs online resharding pipelines with Spring Batch, implements shard health monitoring and alerting. Creates internal frameworks for standardizing sharding patterns.

Defines MySQL standards for the team: naming conventions, migration workflow, query performance budgets. Conducts schema and query reviews. Plans capacity and scaling strategy.

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.

Defines query performance standards for the team: execution time budgets, mandatory profiling for new endpoints. Implements automatic slow query monitoring in production.

Defines team transaction standards: @Transactional usage rules, default isolation levels, conflict handling strategies. Conducts transaction boundary reviews.

Defines API documentation standards for the team: mandatory sections, examples, changelog format. Implements docs-as-code approach. Ensures developer experience through developer portal.

Defines product versioning policy: deprecation strategy, minimum support window, communication plan for breaking changes. Implements automated compatibility testing in pipeline.

Defines product GraphQL strategy: schema conventions, federation architecture, performance budgets. Implements schema registry and breaking change detection in CI.

Standardizes gRPC development in the company's Java ecosystem: creates code-generation plugins for uniform services, implements proto-lint in CI/CD, designs patterns for gRPC integration with Kafka and Spring Cloud. Trains teams on gRPC API design best practices.

Standardizes rate limiting in Java ecosystem: creates Spring Boot starter for standard rate limiting setup, designs centralized quota management service, implements analytics for rate limit effectiveness. Defines rate limiting policies for API monetization.

Defines product API standards: naming conventions, error format, pagination strategy, versioning policy. Implements contract-first development and automated contract testing. Conducts API design reviews.

Defines product AWS strategy: account structure, networking (VPC peering/Transit Gateway), security baseline. Implements FinOps practices. Conducts Well-Architected reviews.

Defines team Docker standards: base image policy, layer caching strategy, image size budgets. Implements automated scanning in CI. Standardizes docker-compose for all services.

Defines team K8s standards: deployment strategies (rolling, canary), resource quotas, pod security standards. Implements GitOps and Infrastructure as Code. Conducts capacity planning.

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

Defines team CI/CD standards: pipeline templates, branching strategy, release process. Implements automated rollback and feature flags. Monitors deployment frequency and lead time.

Defines integration testing standards: mandatory scenarios for each endpoint, test environment management, test data strategy. Implements contract testing in inter-service communication.

Defines team testing strategy: test pyramid (unit → integration → E2E), coverage targets, BDD for acceptance criteria. Implements automated quality gates. Balances development speed and coverage.

Defines Testcontainers standards for the Java team: shared container definitions, custom modules for internal services, CI configuration for Docker-in-Docker. Optimizes test execution time through container reuse.

Defines team unit testing standards: mandatory coverage, naming conventions, test review criteria. Implements mutation testing (PIT) for test quality assessment. Monitors test health metrics.

Defines authentication/authorization strategy: SSO, MFA, session management. Implements identity governance. Conducts security review of auth solutions. Manages Keycloak/Auth0 configuration.

Defines team security standards: OWASP compliance checklist, security review process, incident response plan. Conducts security-focused code reviews. Trains developers on secure coding practices.

Establishes team secure coding standards: mandatory security checks in PRs, approved crypto libraries, data classification policy. Implements security training and secure code review process.

Introduces Copilot to the team: configures policies, defines usage boundaries, trains on effective practices. Evaluates ROI. Monitors security aspects: secret leaks, license compliance.

Defines architectural standards: module structure, dependency rules, ArchUnit tests for architecture control. Balances architecture cleanliness with delivery speed. Conducts architectural reviews.

Standardizes CQRS in the company's Java ecosystem: defines when to apply full CQRS vs simplified read/write separation, designs event store infrastructure (Axon Server vs EventStoreDB vs custom), standardizes CQRS component testing strategy. Trains teams on DDD + CQRS.

Makes architectural decisions: monolith vs microservices, Spring Cloud vs Kubernetes-native, sync vs async. Documents ADRs. Conducts architectural reviews and mentors senior developers.

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.

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.

Defines OpenTelemetry standards: mandatory spans, naming conventions, attribute policies. Implements trace-based alerting. Uses traces for performance analysis and dependency mapping.

Defines monitoring strategy: mandatory metrics, SLO, error budget policy. Implements observability culture. Conducts post-mortems with metrics and traces.

Defines logging standards: mandatory MDC fields, log level policy, retention. Implements log-based alerting. Conducts logging review during incidents. Ensures compliance.

Shapes code review culture: defines checklists by level, sets review SLAs, automates checks (SonarQube, ArchUnit). Resolves disagreements. Conducts ADR reviews.

Shapes team Git workflow: branching model, PR process, review requirements, CODEOWNERS. Defines mono/multi-repo rules. Implements automation: required checks, auto-merge for dependabot.