Independently implements Apache Kafka tasks in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.

Independently designs schemas and optimizes queries with ClickHouse. Understands indexing and query execution plans. Uses sqlx/GORM effectively.

Independently implements tasks with Go Web Frameworks in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.

Designs gRPC services in Go: defines .proto contracts with message validation, implements unary and server-streaming RPC. Configures grpc-gateway for REST proxy, applies interceptors for logging, authentication, and tracing via OpenTelemetry.

Independently implements tasks with NATS / NATS JetStream in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.

Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses sqlx/GORM effectively.

Implements rate limiting in Go services: uses go-redis/redis_rate for distributed rate limiting, implements per-key limiting with custom key extraction (IP, user ID, API key). Applies GCRA (Generic Cell Rate Algorithm) for smooth traffic shaping and configures response headers.

Independently implements tasks with Redis in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.

Designs REST APIs in Go with full CRUD functionality via Gin/Echo/Chi: input validation, pagination, filtering, sorting. Implements middleware chains for authentication, CORS, request ID, and structured logging via zerolog/zap.

Independently applies algorithmic thinking in Go: selects efficient sorting/searching for data processing, understands goroutine scheduling implications, evaluates concurrent algorithm patterns with channels. Analyzes complexity of data processing pipelines in Go services.

Independently applies async programming in Go: goroutines with proper lifecycle management, channel-based coordination patterns, context propagation for cancellation. Understands trade-offs between channels and sync primitives, fan-out/fan-in patterns.

Maintains complete OpenAPI documentation for Go services via swaggo: model descriptions, request/response examples, authentication. Configures automatic documentation generation in CI and publishing through Swagger UI or Redoc.

Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses sqlx/GORM effectively.

Independently applies code quality practices in Go development. Writes idiomatic Go code with proper error handling, context usage, and goroutine management. Understands trade-offs between interface design simplicity and flexibility. Reviews code for race conditions, resource leaks, and package structure clarity.

Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses sqlx/GORM effectively.

Independently applies multithreading in Go: goroutines with proper lifecycle management, channels for safe inter-goroutine communication, sync.WaitGroup and context for coordination, select for multiplexing channel operations. Explains Go concurrency pattern trade-offs in code review.

Independently designs schemas and optimizes queries. Understands indexing and query execution plans. Uses sqlx/GORM effectively.

Independently applies design patterns for Go: interface-based strategy and adapter patterns, functional options for configuration, middleware pattern for HTTP handling, channel-based observer/pub-sub. Explains Go-idiomatic pattern alternatives in code review.

Independently applies SOLID principles in Go: interface-based service contracts, composition over inheritance via struct embedding, single responsibility in handler/service/repository layers. Understands Go-specific trade-offs — implicit interfaces, accept interfaces return structs, small interface design.

Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses sqlx/GORM effectively.

Implements API versioning in Go services: parallel support for multiple versions via router groups, deprecation strategy with Sunset headers. Develops adapters between versions and backward compatibility tests via go test.

Independently implements caching strategies in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.

Independently selects appropriate data structures in Go: slices vs arrays for collection handling, maps with proper key types, channels for goroutine communication patterns. Understands trade-offs between pointer and value receivers for data encapsulation and memory allocation.

Understands Go memory model: stack vs heap allocation, escape analysis, and garbage collector (concurrent tri-color mark-and-sweep). Profiles memory usage with pprof and runtime/metrics. Minimizes heap allocations through value semantics and sync.Pool. Understands goroutine stack growth and implications for high-concurrency services.