What a Lead } should know

Establishes performance budgets for API endpoints. Conducts code reviews focused on complexity. Implements automated monitoring for performance degradation. Makes decisions about architectural trade-offs.

Defines async processing strategy for the product: choosing between sync API, async jobs, event streaming. Implements error handling and queue monitoring standards.

Shapes code quality standards for the team. Configures quality gates in the pipeline. Balances development speed and quality. Implements continuous refactoring practices.

Defines data handling standards for the team. Reviews structure choices in the context of scalability and maintainability. Implements DTOs and Value Objects as the foundation of the domain layer.

Shapes team architectural standards based on patterns. Decides which patterns to apply at project level. Conducts architectural reviews focused on correct pattern application.

Defines OOP standards for the team: coding guidelines, architectural decision records. Trains developers on correct principle application. Conducts design reviews of new modules.

Defines typing strategy for the codebase: strict_types, PHPStan level, generics via annotations. Implements Value Objects and enums for business logic. Controls type coverage via CI.

Designs Kafka platform for the organization: multi-cluster, topic governance, schema registry. Implements event-driven architecture as an organizational pattern. Designs event sourcing with Kafka. Optimizes costs (retention, compression, tiered storage). Standardizes event schemas and contracts.

Shapes caching standards for all services: naming conventions, TTL policies, alerting on degradation. Makes decisions about caching technology selection for different layers.

Defines full-text search strategy for the product: engine selection, indexing schema, synchronization pipeline with the main database. Standardizes search-as-a-service approach.

Standardizes messaging in the PHP ecosystem: defines async communication patterns considering PHP process model limitations, implements Ecotone Framework for CQRS/event sourcing, designs PHP monolith integration with event-driven microservices. Trains teams on messaging best practices.

Defines architectural decisions for PHP Frameworks at product level. Establishes standards. Conducts design reviews and defines technical roadmap.

Defines inter-service communication strategy: sync vs async, RPC vs events. Standardizes message format and contracts. Implements monitoring and alerting for queues.

Defines caching strategy for the product: cache levels (app, HTTP, CDN), invalidation policies, hit rate monitoring. Standardizes caching approaches across the team.

Defines background processing standards: job class structure, error handling, retry policies, monitoring. Chooses between different queue backends based on workload.

Standardizes connection management for the PHP platform: defines connection architecture (FPM + PgBouncer vs Swoole native pool), creates monitoring and alerting for connection utilization. Designs capacity planning for database connections considering PHP scaling patterns.

Defines data modeling standards: naming conventions, mandatory fields (timestamps, soft deletes), schema versioning approach. Reviews models for new modules.

Defines indexing standards for the team: mandatory EXPLAIN in code review, automated monitoring of unused indexes, periodic reindex policy. Trains the team on query optimization.

Defines migration process for the team: migration reviews, automated rollback testing, staged deployment. Plans complex migrations with phased breakdown.

Defines MySQL standards for the team: naming conventions, migration workflow, schema review. Makes decisions about sharding, read replicas for read-heavy workloads. Plans capacity.

Defines PostgreSQL standards for the team: schema design guidelines, migration process, monitoring. Makes decisions about extensions (PostGIS, pg_trgm, TimescaleDB).

Implements performance-aware development culture: mandatory query review, automated slow query alerts, performance budgets for endpoints. Trains the team on reading execution plans.

Defines transactional standards: retry policies, timeouts, long-running transaction monitoring. Trains the team on proper isolation level usage and concurrent access.

Defines API documentation standards: mandatory sections, review process, automated freshness checks. Builds developer experience: onboarding, sandbox, changelog.

Defines API testing standards: coverage requirements, mandatory test cases, performance budgets for endpoints. Implements automated regression testing.

Defines versioning policy for the product: number of supported versions, deprecation timeline, change communication. Standardizes the process for releasing new API versions.

Defines GraphQL standards for the team: schema conventions, review process, monitoring. Makes decisions about GraphQL vs REST vs gRPC applicability for different scenarios.

Standardizes rate limiting in the PHP ecosystem: creates reusable Composer packages, designs centralized rate limit configuration via database/config service, implements monitoring for rate limit metrics. Defines API usage policies for SaaS products.

Defines API design guidelines for the team: naming conventions, error format, pagination strategy. Conducts API design reviews. Implements contract-first development approach.

Defines product cloud strategy: service selection, cost budgets, security baseline. Implements FinOps practices. Standardizes IaC approach and modules for the team.

Defines containerization standards: base images, security policies, CI/CD pipeline for docker builds. Implements container scanning and vulnerability management.

Defines Kubernetes standards for the team: Helm charts, deployment pipeline, monitoring stack. Plans capacity and cost optimization. Trains the team on operational practices.

Defines CI/CD standards for the team: mandatory checks, deployment policy, environment management. Implements GitOps practices. Monitors deployment frequency and lead time.

Defines integration testing standards: mandatory scenarios, performance testing, environment management. Implements automated integration testing in the deployment pipeline.

Shapes testing culture in the team: code review with test focus, coverage goals, TDD workshops. Balances development speed and test coverage.

Defines unit testing standards: minimum coverage, what must be tested, test reviews. Implements automated coverage tracking and quality gates in CI.

Defines authentication/authorization strategy for the product: identity provider, token format, session management policy. Standardizes auth approach across services.

Defines security standards for the team: secure coding guidelines, mandatory security review, dependency scanning. Coordinates vulnerability remediation. Trains the team on secure development.

Implements secure development lifecycle: threat modeling at design phase, automated security testing, post-deployment scanning. Develops security champions in the team.

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

Defines team architectural standards: module structure, dependency rules between layers, PHPStan rules for architecture enforcement. Conducts architectural reviews. Balances architecture purity with delivery speed.

Makes architectural decisions for the product: choosing between monolith and microservices, defining service boundaries, data strategy. Documents ADRs. Conducts architectural reviews and mentors senior developers.

Defines monitoring strategy for the product: mandatory metrics, SLOs, error budget policy. Implements observability culture in the team. Conducts post-mortem analysis of incidents using metrics and traces.

Defines logging standards for the team: mandatory fields, levels, retention policies. Implements log-based monitoring and alerting. Reviews logging during incidents. Ensures compliance requirements for log storage.

Shapes code review culture in the team: defines what to check at each level, establishes review SLAs, implements automated checks. Reviews architectural decisions and ADRs. Resolves disagreements in the review process.

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