What a Mid-level } should know

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.

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 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.

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.

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.

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 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 implements Apache Kafka tasks in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.

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

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

Confidently works with message brokers in Go: implements consumer groups in Kafka via segmentio/kafka-go or Sarama, configures NATS JetStream for durable messaging, applies worker pool patterns for parallel processing. Handles poison messages and configures retry with backoff.

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

Independently implements tasks with Redis 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.

Optimizes connection pooling in Go: calculates optimal pool parameters based on workload, configures pgxpool for PostgreSQL with prepared statements, implements connection health checking. Monitors pool stats via sql.DBStats and custom metrics.

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

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

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

Works with sharded databases in Go: implements shard-aware repository layer with connection pooling per shard, applies consistent hashing for data distribution, handles cross-shard queries via scatter-gather pattern. Uses context for shard info propagation.

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

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

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.

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.

Confidently develops gRPC services in Go: implements all RPC types (unary, server/client/bidirectional streaming), configures interceptors for tracing and metrics, uses metadata for context propagation. Applies grpc-middleware for standard cross-cutting concerns.

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.

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.

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.

Applies networking knowledge in Go services: configuring http.Transport with connection pooling and TLS, gRPC over HTTP/2, DNS-based service discovery. Debugs network issues via tcpdump/wireshark, configures keep-alive and timeout policies for Go HTTP clients.

Writes Terraform configurations for cloud resources (VPC, EC2/Compute, RDS, S3). Uses modules for reusability. Works with remote state (S3/GCS backend). Uses workspaces or directories for different environments. Imports existing resources.

Implements CQRS in Go projects: creates separate packages for commands and queries, uses interface-based dispatch for command/query bus, designs read-optimized structures (denormalized views) separate from write models. Applies Go channels for internal event propagation between models.

Defines SLIs for Go services — p99 latency from middleware metrics, error rate from structured logs, and availability from health checks. Configures Prometheus-based SLI monitoring with recording rules. Understands error budgets and manages them for iterative feature releases. Participates in Go service on-call rotation.