What a Senior } should know

Applies algorithmic expertise in Go development: concurrent algorithm design with goroutines and channels, work-stealing scheduling patterns, efficient sorting for large datasets with minimal allocations. Designs rate limiting and circuit breaker algorithms for distributed Go services.

Designs async architectures in Go: goroutine pool patterns, channel-based pipeline architectures, context-driven cancellation propagation. Mentors team on avoiding goroutine leaks, race condition prevention, and efficient concurrency patterns.

Designs code quality standards for Go projects: golangci-lint configuration, interface design patterns, error handling conventions. Refactors complex goroutine-based systems for clarity and race-condition safety. Establishes idiomatic Go review guidelines covering context propagation, channel usage, and package structure.

Selects optimal data structures for Go applications: sync.Map for concurrent access patterns, ring buffers for high-throughput pipelines, channel-based queues for goroutine communication. Optimizes memory layout with struct alignment and slice pre-allocation. Designs zero-allocation data processing using unsafe.Pointer when justified.

Has deep expertise in design patterns for Go: designs clean architectures with interface-driven abstractions, implements Go-idiomatic patterns replacing classical OOP approaches, optimizes concurrent patterns with goroutines and channels. Mentors team on Go-specific architectural patterns for production systems.

Designs memory-optimized Go service architectures: custom allocators for hot paths, zero-allocation JSON/protobuf processing, and memory-mapped file I/O. Tunes GC parameters (GOGC, GOMEMLIMIT) for latency-sensitive services. Implements memory pressure monitoring and graceful degradation. Mentors team on escape analysis, allocation reduction, and pprof-driven optimization.

Has deep expertise in Go concurrency: designs concurrent systems with proper goroutine lifecycle management, implements advanced channel patterns (fan-in/fan-out, pipeline), optimizes Go runtime scheduler tuning for high-throughput services. Mentors team on Go concurrency patterns for production systems.

Applies SOLID principles in Go's composition-based design: interface segregation with small focused interfaces, dependency inversion through constructor injection, single responsibility in package organization. Designs clean Go architectures using composition over inheritance, embedding for behavior reuse, and interface satisfaction patterns.

Implements Kafka producers and consumers in Go using confluent-kafka-go or segmentio/kafka-go. Configures consumer groups, manages offsets, handles errors via Dead Letter Queue, and ensures exactly-once semantics with idempotent handlers.

Implements multi-level caching in Go services: in-process cache via groupcache/ristretto, Redis as L2, HTTP caching with ETag. Applies cache stampede protection via singleflight and monitors cache effectiveness through pprof and metrics.

Designs solutions based on Go Web Frameworks for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.

Designs messaging systems in Go: implements transactional outbox via database polling or CDC, designs idempotent consumers with deduplication, configures message ordering guarantees. Optimizes throughput through batch processing and zero-allocation serialization.

Designs high-throughput NATS/JetStream architectures in Go services. Implements consumer groups, key-value stores, and stream mirroring for resilient event-driven systems. Mentors team on messaging patterns.

Integrates Redis into Go services via go-redis: implements caching with TTL, distributed locks via Redlock, pub/sub for invalidation. Applies command pipelining to reduce latency and monitors hit rate via Prometheus client_golang.

Integrates ClickHouse into Go services for analytics: batch inserts via clickhouse-go with buffering, materialized views, date-based partitioning. Optimizes queries considering MergeTree engines and columnar storage.

Designs connection management for Go microservices: configures read/write pool separation for replica routing, implements connection warming at startup, designs graceful connection drain at shutdown. Optimizes pool for high-concurrency scenarios considering goroutine scheduling.

Designs optimal data schemas for Go microservices: denormalization strategies for read-heavy workloads, JSON columns in PostgreSQL, partitioning. Develops domain models through clean architecture with entity and value object separation.

Designs optimal indexes for Go services: composite, partial, GIN/GiST indexes in PostgreSQL, ClickHouse indexes. Analyzes pg_stat_user_indexes to identify unused indexes, configures index bloat monitoring via Prometheus.

Develops safe migrations for production Go services: zero-downtime ALTER via adding new columns, backfill scripts, migrations with locking via pg_advisory_lock. Configures automatic migration execution in CI/CD pipeline.

Designs sharding for Go microservices: develops sharding middleware with pluggable shard key strategies, implements online resharding with dual-write pattern, configures Vitess integration for Go applications. Optimizes connection management for 100+ shards via pgbouncer/ProxySQL.

Optimizes PostgreSQL usage in Go: uses pgxpool for connection pool management, applies COPY protocol for bulk operations, implements advisory locks. Analyzes EXPLAIN ANALYZE for query optimization and configures monitoring via pg_stat_statements.

Optimizes complex SQL queries in Go services: CTEs, window functions, JOIN strategy optimization. Profiles query time via pgx tracing, configures slow query log and analyzes pg_stat_statements to identify problematic patterns.

Develops API documentation strategy for Go services: auto-generation from protobuf for gRPC, contract-first approach for REST. Implements API changelog, integration examples and SDK documentation, configures code-to-spec compliance validation.

Designs versioning strategy for Go microservices: semantic versioning for APIs, automatic breaking change detection via protobuf/OpenAPI diff. Implements graceful migration between versions with canary deployment support.

Designs high-load gRPC services in Go: optimizes through connection multiplexing, configures client-side load balancing (round-robin, weighted), implements graceful shutdown with drain period. Integrates gRPC with OpenTelemetry for distributed tracing and configures TLS/mTLS.

Develops advanced gRPC services in Go: bidirectional streaming, deadline propagation via context, retry policies through grpc-middleware. Optimizes protobuf serialization, configures connection pooling and load balancing via gRPC name resolver.

Designs rate limiting architecture for Go microservices: implements local + global rate limiting via sidecar pattern, configures rate limiting in service mesh (Envoy/Istio), designs backpressure mechanisms through Go channels. Optimizes Redis-based rate limiter for minimal latency overhead.

Develops scalable REST APIs in Go: graceful shutdown via context.Context, versioning through URL/headers, HATEOAS links. Applies Clean Architecture with handler/service/repository separation, configures OpenAPI generation via swaggo.

Designs cloud-native Go architecture on AWS: Lambda with custom Go runtime, API Gateway, DynamoDB for serverless scenarios. Optimizes cold start, applies Infrastructure as Code via CDK/Terraform, configures cross-region replication and disaster recovery.

Designs containerization strategy for Go services: distroless images for security, BuildKit module caching, vulnerability scanning via Trivy. Optimizes CI/CD pipeline for fast builds with layer caching, configures multi-arch builds for ARM/AMD64.

Designs Kubernetes deployment for Go microservices: Helm charts with values for different environments, Pod Disruption Budgets, resource quotas optimized for Go runtime. Configures service mesh (Istio/Linkerd) for traffic management and mutual TLS between Go services.

Designs network architecture for Go microservices: service mesh networking, mutual TLS, network policies in Kubernetes. Optimizes TCP parameters for high-load Go services, configures DNS caching and connection reuse for latency minimization.

Designs modular Terraform architecture for Go microservices on Kubernetes. Creates reusable modules for GKE/EKS clusters, service mesh, and observability stacks. Implements Terragrunt for DRY multi-cluster configurations. Implements policy as code (OPA/Kyverno) for infrastructure compliance. Automates drift detection and reconciliation.

Designs advanced CI/CD pipelines for Go microservices: matrix builds, reusable workflows, security scanning with Trivy and gosec. Optimizes build time through caching and parallelism, configures canary deployment and automatic rollback.

Designs integration testing strategy for Go services: testcontainers-go for all dependencies, contract testing via Pact for inter-service communication. Implements test fixture factories, parallel execution with isolation through separate database schemas.

Introduces TDD culture in Go development: designs testable architecture with dependency injection, uses interfaces for mocking via mockgen/mockery. Develops acceptance tests through httptest and testcontainers-go, configures coverage reports in CI.

Develops advanced Go testing strategies: property-based tests via rapid, fuzz testing via go test -fuzz, benchmark tests for critical paths. Creates test helpers and custom matchers for testify, configures parallel test execution for CI acceleration.

Designs authentication and authorization system for Go microservices: centralized auth service, token propagation via context, RBAC/ABAC. Implements token rotation, revocation via Redis blacklist, configures mutual TLS for service-to-service authentication.

Designs Go service protection per OWASP: API threat modeling, WAF rules, security headers, CSP. Implements dependency scanning via govulncheck, configures SAST/DAST in CI pipeline, conducts security code review for the team.

Designs secure Go service architecture: secrets management via HashiCorp Vault, mutual TLS for inter-service communication, audit logging. Implements static analysis via gosec with custom rules, conducts threat modeling and security code review.

Optimizes Go development through Copilot: generates complex architectural components, integration tests, infrastructure code. Configures .github/copilot-instructions.md for Go project conventions, trains Copilot on microservice architecture context.

Designs CQRS architecture for Go microservices: implements event-driven projections via Watermill or custom event bus, configures async projection rebuilds with checkpoint tracking, ensures projection idempotency. Optimizes read models for specific query patterns with materialized views.

Designs high-load Go services: horizontal scaling, data sharding, async processing via Kafka. Optimizes Go runtime (GOGC, GOMAXPROCS), applies zero-allocation patterns, configures load testing via k6/vegeta.

Designs Go system decomposition: defines service boundaries through domain analysis, event storming, data ownership. Implements saga pattern via Kafka for distributed transactions, designs shared libraries and Go SDK for common functionality.

Designs Go microservice architecture: event-driven via Kafka, CQRS for read/write separation, saga pattern for distributed transactions. Designs API contracts, defines service boundaries and data strategies, documents via Architecture Decision Records.

Designs observability strategy on OpenTelemetry for Go services: custom instrumentation, tail-based sampling, trace-based testing. Develops middleware for automatic trace/log/metric correlation, optimizes tracing overhead for production.

Designs monitoring system for Go microservices: standard metrics via middleware, cardinality management, Prometheus federation. Develops SLO-based alerting, custom Prometheus exporters in Go, optimizes PromQL queries for complex dashboards.

Defines and implements comprehensive SLOs for Go service portfolios with multi-signal burn rate alerting. Creates SLO dashboards correlating latency, error rate, and saturation metrics through distributed tracing. Manages error budgets driving release velocity decisions. Conducts structured post-mortem analysis and coordinates cross-service incident response. Designs graceful degradation patterns with circuit breakers and load shedding.

Designs logging strategy for Go services: log correlation via trace_id/span_id from OpenTelemetry, dynamic log levels, audit logging. Optimizes logging performance through zero-allocation zerolog, configures log aggregation in Loki/ELK.

Performs architectural code review of Go microservices: evaluates API contracts, concurrency patterns, performance characteristics. Analyzes escape analysis and allocations via benchmarks, reviews database migrations and Kubernetes manifests, mentors through PR comments.

Designs Git strategy for Go microservices: mono-repo vs multi-repo with Go modules, CODEOWNERS configuration, branch protection rules. Optimizes CI for large Go repositories via sparse checkout and path-based triggers, introduces conventional commits.

Designs CPU profiling strategy for Go services: continuous profiling via Parca/Pyroscope, production-safe sampling. Optimizes critical paths through escape analysis, inline hints, SIMD optimizations. Configures automatic regression benchmarks in CI via benchstat.

Designs low-latency Go services: zero-allocation hot paths, pre-allocated buffers, GOGC/GOMEMLIMIT tuning for minimizing GC pauses. Applies connection multiplexing, batch processing, prefetching. Configures p99 latency monitoring via Prometheus histograms.