What a Lead } should know

Defines algorithmic standards for engineering team: performance optimization review processes, algorithm selection guidelines, computational complexity assessment practices. Conducts architectural reviews of algorithmic decisions in system-critical components.

Defines async programming standards for engineering team: concurrency pattern guidelines, async architecture reviews, error handling standards for async code. Establishes best practices for async patterns across team projects.

Defines code quality standards for engineering team: code review process design, refactoring prioritization framework, automated quality tool adoption. Conducts architectural reviews of system-critical components. Establishes team-wide quality metrics and improvement cycles.

Defines data structure standards for engineering team: data model design review processes, database schema conventions, API data format guidelines. Conducts architectural reviews of data structure decisions. Establishes team knowledge base on data structure selection for common system patterns.

Defines design pattern standards for technical teams: establishes architectural review practices for pattern consistency across services, creates guidelines for pattern selection and refactoring strategies, conducts training on advanced patterns and anti-pattern recognition.

Defines multithreading standards for technical teams: establishes guidelines for concurrent system architecture selection, conducts reviews of multi-threaded code for safety and performance, creates training materials on advanced concurrency patterns and anti-patterns.

Defines OOP/SOLID standards for engineering team: design pattern usage guidelines, architectural review processes for class hierarchies, refactoring strategies for legacy code. Conducts reviews ensuring consistent application of SOLID principles across all team projects.

Defines API gateway standards for engineering teams: designs gateway topology for microservice ecosystems, establishes API contract and versioning conventions, implements centralized auth and observability through gateways. Leads cross-team API design reviews.

Defines GraphQL API strategy across product domains. Establishes schema design standards, federation governance, and API lifecycle management processes. Conducts cross-team schema design reviews and coordinates unified API experience across consumer applications.

Defines API strategy at the product level. Establishes design standards. Conducts API design reviews. Coordinates cross-team API interaction.

Defines API strategy for team at product level: API design standards and review processes, versioning and deprecation governance, API documentation and portal requirements. Conducts API architecture reviews and establishes API quality standards for the team.

Defines AWS infrastructure strategy for product platform workloads spanning development and production environments. Establishes IaC standards for microservice deployments, observability, and cost governance. Conducts architecture reviews of team AWS configurations and drives FinOps optimization for product infrastructure.

Defines Docker infrastructure strategy for team: base image standardization, container CI/CD pipeline governance, development environment container policies. Conducts architecture reviews for containerized deployments and optimizes FinOps for team container resources.

Defines Kubernetes infrastructure strategy for product platform workloads across development and production environments. Establishes IaC standards for deployment patterns, observability, and cost management. Conducts architecture reviews of team Kubernetes configurations and coordinates cross-team infrastructure decisions and FinOps optimization.

Defines IaC strategy for the product organization. Evaluates Terraform vs Pulumi vs Crossplane for different use cases. Implements self-service infrastructure via Terraform modules integrated with developer portal (Backstage). Designs multi-account/multi-project landing zones. Drives FinOps through infrastructure tagging and cost estimation in CI. Manages Terraform at scale (1000+ resources).

Defines technical standards for feature flag platforms across the engineering organization. Establishes flag evaluation performance SLAs and reliability requirements. Drives adoption of flag-based testing strategies including dark launches and shadow traffic. Reviews flag architectures for complex cross-service features.

Defines DevOps strategy for technical teams: establishes CI/CD standards for developer productivity and delivery reliability, implements platform engineering approaches for deployment automation, drives engineering excellence through CI/CD best practices.

Defines security strategy for product development workflows across team boundaries. Establishes security policies for threat modeling requirements, security gate automation, and dependency vulnerability management. Coordinates cross-team security reviews and trains development teams on OWASP-aware architecture design.

Defines secrets management strategy at the product/department level. Establishes standards for secret rotation policies, audit logging requirements, and access control patterns. Evaluates Vault Enterprise features vs open-source for team needs. Drives adoption of automated secret management across all services.

Defines GitHub Copilot strategy for technical teams: establishes prompt engineering standards and code review workflows for AI-generated code, designs metrics for measuring AI-assisted development effectiveness, drives Copilot adoption aligned with technical excellence practices.

Defines the product's architectural strategy with Architecture Decision Records. Establishes architecture guidelines. Conducts architecture reviews.

Defines fitness function standards across engineering teams: designs reusable fitness function libraries, establishes architectural compliance dashboards, integrates fitness functions into architecture review processes. Leads adoption of evolutionary architecture practices through measurable quality gates.

Defines the product's architectural strategy with Clean Architecture. Establishes architecture guidelines. Conducts architecture reviews.

Defines the product's architectural strategy with DDD Strategic Patterns. Establishes architecture guidelines. Conducts architecture reviews.

Defines the product's architectural strategy with DDD Tactical Patterns. Establishes architecture guidelines. Conducts architecture reviews.

Defines the product's architectural strategy with Hexagonal Architecture. Establishes architecture guidelines. Conducts architecture reviews.

Defines the product's architectural strategy with High Load Architecture. Establishes architecture guidelines. Conducts architecture reviews.

Defines the product's architectural strategy with Microservices Decomposition. Establishes architecture guidelines. Conducts architecture reviews.

Defines the product's architectural strategy with System Design Fundamentals. Establishes architecture guidelines. Conducts architecture reviews.

Defines the product's architectural strategy with Technical Debt Management. Establishes architecture guidelines. Conducts architecture reviews.

Defines the product's architectural strategy with Technology Radar. Establishes architecture guidelines. Conducts architecture reviews.

Defines on-call management strategy for the product. Establishes SLO-based alerting approach, incident management framework, and post-mortem process. Coordinates cross-team incident response. Optimizes MTTD/MTTR through observability improvements and automated remediation.

Defines the product's observability strategy. Establishes SLO-based approach. Coordinates incident management. Optimizes MTTD/MTTR.

Defines observability strategy for technical products with Prometheus & Grafana: establishes SLO-based approach for service reliability targets, coordinates incident management and on-call practices, optimizes MTTD/MTTR through improved monitoring and alerting standardization.

Defines product observability strategy for team-owned service portfolios — establishes SLO-based approach for microservice reliability, coordinates incident management with dependent teams, and optimizes MTTD/MTTR through improved monitoring and on-call processes.

Defines observability strategy for technical products: establishes SLO-based approach for service reliability targets, coordinates incident management and on-call practices across teams, optimizes MTTD/MTTR through improved monitoring, alerting, and runbook standardization.

Defines code review strategy for the team: review process standards and SLAs, quality gate definitions, constructive feedback guidelines. Establishes review culture that balances thoroughness with developer productivity.

Defines documentation-as-code strategy at the product/department level. Establishes standards for API documentation, architecture decision records, and developer guides. Drives adoption of developer portal (Backstage, Docusaurus) for centralized documentation. Creates governance for documentation ownership and maintenance.

Defines Git strategy for technical teams: establishes branching and merge policies optimized for team delivery metrics, designs Git hook ecosystems for automated quality enforcement, drives adoption of advanced Git techniques (worktrees, sparse checkout) for developer productivity.

Defines InnerSource technical strategy: shared platform architecture, reusable component libraries, and cross-team development standards. Establishes technical governance for internal open-source projects with release management and versioning policies.

Defines Monorepo Tools strategy at the team/product level. Establishes standards and best practices. Conducts reviews.

Defines architecture documentation strategy at the team and product level, selecting appropriate C4 depth and arc42 sections per service criticality. Establishes best practices for ADR authoring including templates, status workflows, and linking to implementation PRs. Conducts regular architecture documentation reviews to prevent drift between diagrams and actual system state. Champions documentation-as-code culture with automated rendering and publishing pipelines.

Defines diagramming strategy for technical design documentation, component modeling, and data flow visualization at the team level. Establishes standards for sequence diagrams, API interaction visuals, and system boundary maps. Conducts reviews of technical diagram clarity and accuracy.