What a Lead } should know

Designs algorithmically efficient Go services, analyzing complexity via pprof and benchmarks (go test -bench). Reviews team code for suboptimal data structures, teaches choosing between slice, map and sync.Map for concurrent scenarios.

Designs concurrency patterns for the Go team services: goroutine and channel pipelines, fan-out/fan-in, rate limiting via time.Ticker. Reviews context.Context usage for operation cancellation and errgroup for managing goroutine groups.

Configures golangci-lint with custom team configuration: enables staticcheck, gosec, gocritic, errcheck. Implements mandatory go vet and gofumpt in pre-commit hooks, establishes test coverage standards and quality metrics via SonarQube for Go.

Leads data structure selection across Go team services: slice, map, heap from container/heap, ring buffers. Conducts code reviews focused on allocations and escape analysis, configures pprof profiling to identify bottlenecks in data structures.

Adapts classic patterns to idiomatic Go: functional options, middleware chains in Gin/Chi, graceful shutdown via context.Context. Reviews team architectural decisions, ensuring adherence to Go conventions and interface composition principles.

Profiles Go services via pprof (heap, allocs, goroutine) to detect memory leaks and excessive allocations. Trains the team on escape analysis (go build -gcflags=-m), GC optimization via GOGC, and efficient sync.Pool usage to reduce garbage collector pressure.

Manages concurrency in Go team services: sync.Mutex, sync.RWMutex, sync.WaitGroup, atomic operations. Configures go vet and race detector (-race) in CI pipeline, trains the team on avoiding data races and proper sync.Pool usage.

Trains the team on idiomatic Go design approach: composition via struct embedding, small interfaces (io.Reader, io.Writer), interface segregation principle. Reviews code for excessive abstractions and SOLID violations in the Go context.

Designs event-driven architecture on Kafka for Go microservices: topic schemas, partitioning strategies, consumer lag monitoring via Prometheus. Standardizes serialization approach (protobuf/Avro) and introduces shared Go libraries for Kafka integration.

Designs caching strategies for Go microservice architecture: distributed invalidation, cross-service cache consistency, CDN integration. Standardizes caching approaches across the team and TTL/hit-rate metrics for Grafana dashboards.

Makes architectural decisions on Go Web Frameworks at the product level. Defines standards. Conducts design reviews and determines the technical roadmap.

Defines messaging architecture for the Go platform: standardizes internal event bus via Watermill or custom framework, designs event schema management with Protobuf/Avro, implements distributed tracing for message flows. Develops saga orchestration and compensation patterns.

Makes architectural decisions on NATS / NATS JetStream at the product level. Defines standards. Conducts design reviews and determines the technical roadmap.

Designs Redis caching strategy for Go microservices: cache-aside, write-through/write-behind patterns, Redis Cluster for horizontal scaling. Standardizes Go wrappers over go-redis with circuit breaker and graceful fallback.

Designs analytical architecture on ClickHouse for the Go platform: ETL pipelines from Kafka to ClickHouse, denormalization strategies, query performance monitoring. Standardizes Go libraries for ClickHouse and defines batch loading patterns.

Standardizes connection management for the Go platform: creates internal library for standard pool setup with observability, designs PgBouncer/ProxySQL integration for connection multiplexing. Defines capacity planning process and alerting for database connection limits.

Defines data modeling standards for the Go platform: naming conventions, partitioning policies, multi-tenant data strategies. Reviews team data architecture, ensuring consistency across microservices.

Defines indexing strategy for Go microservice databases: index creation standards, REINDEX policies, automated analysis via CI. Trains the team on index type selection and reviews migrations for index performance.

Designs migration strategy for Go microservices: naming standards, migration review process, rollback policies. Implements automated migration testing on production data copies and ALTER operation duration monitoring.

Defines sharding strategy for the Go platform: standardizes sharding patterns via internal library, designs monitoring for shard balance and hotspot detection, develops automated resharding pipelines. Defines data placement strategy considering latency and availability.

Designs PostgreSQL architecture for Go microservices: sharding strategies, read replicas, table partitioning. Standardizes migration approach via golang-migrate, configures pgbouncer for infrastructure-level connection pooling.

Establishes query optimization standards for the Go team: mandatory EXPLAIN in migration code reviews, query latency budgets, automated performance tests. Designs denormalization and materialized view strategies for critical data paths.

Defines API documentation standards for the Go team: required fields in OpenAPI specs, endpoint description templates, automated CI checks. Implements developer portal with interactive documentation and versioning for all Go services.

Defines API versioning policy for the Go team: breaking/non-breaking change standards, version lifecycle management, automated compatibility checks in CI. Coordinates client migration between API versions and ensures deprecation notices.

Defines gRPC communication architecture for Go microservices: standardizes error model via google.rpc.Status, designs backward/forward compatibility strategy for proto schemas, implements gRPC reflection for debugging. Develops internal frameworks on top of gRPC for service unification.

Defines gRPC communication standards for Go microservices: .proto repository management, buf lint validation, backward compatibility strategies. Implements service mesh integration, standardizes interceptor chains and gRPC metrics monitoring via Prometheus.

Standardizes rate limiting for the Go platform: creates internal middleware library with pluggable backends, designs configuration-driven rate limiting via dynamic config (etcd, Consul), implements A/B testing for rate limit policies. Defines SLAs and quota policies for the API platform.

Defines REST API standards for the Go microservices team: unified response and error formats, middleware conventions, versioning strategies. Implements API gateway patterns, reviews inter-service contracts and configures automated API testing.

Defines AWS standards for the Go team: best practices for each service, Terraform IaC templates, security and IAM policies. Implements cost optimization practices, reviews architectural decisions and coordinates multi-account strategy.

Defines Docker standards for the Go team: base images, Dockerfile templates, vulnerability scanning policies. Implements automated pipeline for building and publishing images, standardizes docker-compose configurations for all Go microservices.

Defines Kubernetes deployment standards for the Go team: Helm chart templates, resource and limit policies, rolling/blue-green deployment strategies. Implements GitOps via ArgoCD, standardizes the observability stack and configures multi-environment promotion.

Designs IaC strategy for Go-based platform organization. Evaluates Terraform vs Pulumi (Go-native) vs Crossplane for different infrastructure layers. Implements self-service infrastructure via Terraform modules integrated with Backstage. Designs multi-cluster landing zones for Go services. Drives FinOps through automated tagging and cost estimation in CI pipelines. Manages Terraform at scale across multiple teams.

Defines CI/CD standards for the Go team: mandatory checks (lint, test, security scan), reusable workflow templates, deployment policies. Implements GitOps practices, automates release management via semver and changelog generation for Go services.

Defines integration testing standards for the Go team: mandatory E2E scenarios, testcontainers-go configurations, contract tests between services. Implements automated CI execution with reports, configures test environments for staging verification.

Defines TDD/BDD standards for the Go team: mandatory table-driven tests, minimum coverage for merge, test scenario templates. Implements automatic coverage regression monitoring, trains the team on test-first development and property-based testing.

Defines unit testing standards for the Go team: test naming conventions, mandatory table-driven patterns, mocking policies. Implements mutation testing to verify test quality, reviews test code as production code with the same standards.

Defines authentication standards for the Go platform: unified auth middleware, token policies (TTL, rotation), identity federation strategy. Implements centralized identity provider, standardizes RBAC model and configures auth metrics monitoring.

Defines OWASP security standards for the Go team: mandatory gosec + govulncheck in CI, dependency update policies, security review process. Coordinates penetration testing, implements security champions program and team training.

Defines secure coding standards for the Go team: mandatory gosec/govulncheck checks, secret management policies, security review checklist. Implements Go-specific secure coding guidelines, trains the team on vulnerability recognition.

Adopts GitHub Copilot as a productivity tool for the Go team: usage policies, guidelines for reviewing AI-generated Go code, effectiveness metrics. Configures Copilot for Business considering security requirements and organization IP policies.

Defines CQRS strategy for the Go platform: standardizes patterns for command validation and authorization, designs multi-projection architecture for different read-optimized views. Creates internal CQRS framework with standardized error handling and observability.

Defines architectural standards for high-load Go services: capacity planning, SLA/SLO, performance budgets. Implements load testing in CI/CD, coordinates performance reviews and critical path optimization, maintains Architecture Decision Records (ADR).

Leads Go monolith decomposition process: defines migration strategy, prioritizes service extraction, coordinates teams. Establishes inter-service communication standards (gRPC/Kafka), data mesh patterns and ownership model.

Defines architectural standards for the Go team platform: microservice reference architecture, new service templates, inter-service communication patterns. Conducts architecture reviews, coordinates technical strategy and prioritizes tech debt.

Defines OpenTelemetry standards for the Go team: mandatory instrumentation, span naming conventions, sampling policies. Implements unified observability via OTel Collector, configures SLO monitoring based on traces and coordinates OpenTelemetry migration.

Defines monitoring standards for the Go team: mandatory RED metrics, Grafana dashboard templates, SLO framework. Implements monitoring as part of Definition of Done, configures on-call rotation with automatic alerting and incident runbooks.

Defines structured logging standards for the Go team: mandatory log fields, correlation ID propagation, log level policies. Standardizes zerolog/zap configuration across services, integrates with centralized log aggregation.

Defines code review standards for the Go team: mandatory review checklist, review SLA, approval policies. Implements automated checks via golangci-lint in CI, trains the team on effective reviews and builds a culture of constructive feedback.

Defines Git standards for the Go team: branching strategy, commit conventions, merge policies, release tagging. Implements automatic changelog via conventional commits, configures branch protection and required reviews, coordinates cross-repo dependencies.

Defines profiling standards for the Go team: mandatory benchmarks for critical paths, continuous profiling in production, performance budgets. Implements pprof dashboards in Grafana, trains the team on profile interpretation and systematic optimization.

Defines latency budgets for Go services: p50/p95/p99 SLOs, measurement standards via OpenTelemetry, performance regression detection. Implements load testing via k6/vegeta in CI, coordinates critical path optimization and capacity planning.