Alerting & On-Call 1
▼
Understands what SLA (Service Level Agreement) is. Knows that 99.9% availability means ~8.7 hours of downtime per year. Understands why monitoring is needed.
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.
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.
Algorithms & Data Structures 2
▼
Understands the fundamentals of Algorithms & Complexity at a basic level. Applies simple concepts in work tasks using Go. Follows recommendations from senior developers when solving problems.
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.
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.
Defines algorithmic efficiency standards for the entire Go platform. Develops internal libraries with optimal data structures for high-load services, establishes benchmark policies via CI with golangci-lint and pprof profiling.
Understands the fundamentals of Data Structures at a basic level. Applies simple concepts in work tasks using Go. Follows recommendations from senior developers when solving problems.
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.
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.
Designs platform libraries of custom Go data structures: lock-free queues, concurrent map with sharding, memory-efficient stores. Defines memory management and GC optimization standards for all teams in the organization.
API Management 3
▼
Documents Go API endpoints using swaggo-format comments: describes parameters, response types, HTTP status codes. Generates Swagger/OpenAPI spec via swag init and verifies documentation correctness in Swagger UI.
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.
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.
Shapes organizational API documentation culture: unified developer portal for all Go services, contract-first development standards, automatic client SDK generation from specifications. Defines API governance and review processes.
Understands API versioning principles in Go services: URL versioning (/v1/, /v2/), Accept-Version headers. Implements basic versioning via route groups in Gin/Chi, ensuring compatibility when adding new fields.
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.
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.
Shapes organizational API versioning strategy: unified lifecycle rules for all Go services, automated API compatibility testing, platform version negotiation tools. Defines SLAs for deprecated version support and sunsetting processes.
Understands rate limiting fundamentals in Go: token bucket with golang.org/x/time/rate, middleware-based throttling in Gin/Chi, and basic per-IP limiting. Follows team patterns for implementing rate limiters with Redis-backed distributed counters.
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.
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 organizational rate limiting policy for Go platform: multi-level throttling (API gateway + service), adaptive throttling, graceful degradation. Develops platform libraries with distributed rate limiting and automatic limit scaling.
API Protocols 1
▼
Knows gRPC basics in the Go ecosystem: can generate code from .proto files via protoc-gen-go-grpc, make simple unary calls. Understands the structure of generated code and how Protocol Buffers work for serialization.
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.
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.
Shapes infrastructure-wide gRPC strategy: designs gRPC integration with service mesh (Istio, Linkerd), defines cross-language communication patterns, develops monolith-to-gRPC-microservices migration strategy. Contributes to open-source Go gRPC ecosystem development.
Caching 2
▼
Uses caching strategies at a basic level with gin/echo/fiber. Performs simple tasks using existing templates. Understands basic concepts and follows team-adopted practices.
Independently implements caching strategies in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.
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.
Defines organizational caching strategy for Go platform: multi-level cache standards, invalidation policies for eventual consistency, capacity planning. Develops platform caching libraries with automatic monitoring and alerting.
Uses Redis at a basic level with gin/echo/fiber. Performs simple tasks using existing templates. Understands basic concepts and follows team-adopted practices.
Independently implements tasks with Redis in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.
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.
Defines platform caching strategy with Redis for Go infrastructure: multi-level cache (in-memory + Redis), eviction policies, memory fragmentation monitoring. Develops organizational Redis standards including Sentinel/Cluster for HA.
Clean Code & Refactoring 1
▼
Understands the fundamentals of Code Quality & Refactoring at a basic level. Applies simple concepts in work tasks using Go. Follows recommendations from senior developers when solving problems.
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.
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.
Shapes Go code quality culture across the organization: unified .golangci.yml for all projects, code review standards, technical debt metrics. Develops custom linters via go/analysis for business-specific rules and architectural constraints.
Concurrency & Parallelism 2
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using Go. Follows recommendations from senior developers when solving problems.
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.
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.
Develops platform standards for concurrent Go programming: goroutine, channel, and select multiplexing patterns. Creates internal libraries for worker pool, circuit breaker, and graceful shutdown at the infrastructure level.
Understands the fundamentals of Multithreading at a basic level. Applies simple concepts in work tasks using Go. Follows recommendations from senior developers when solving problems.
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.
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.
Defines concurrency processing strategy for the entire Go platform: synchronization standards, goroutine and sync primitive usage policies. Develops lock-free algorithms and optimizes parallelism model for high-load services via GOMAXPROCS tuning.
Data Modeling 2
▼
Designs simple data schemas for Go services: tables with correct types, foreign keys, basic normalization to 3NF. Describes models via GORM tags or golang-migrate SQL files, understands one-to-many and many-to-many relationships.
Independently designs schemas and optimizes queries for data modeling. Understands indexing and query execution plans. Uses sqlx/GORM effectively.
Defines data modeling standards for the Go platform: naming conventions, partitioning policies, multi-tenant data strategies. Reviews team data architecture, ensuring consistency across microservices.
Shapes organizational data modeling strategy: OLTP and OLAP schema design standards, data governance policies, master data. Develops platform tools for visualization and validation of data schemas across all Go services.
Creates simple SQL migrations for Go services using golang-migrate: adding tables, columns, basic indexes. Understands the up/down migration principle, runs migrations locally and verifies idempotency before committing.
Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses sqlx/GORM effectively.
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 organizational database migration policy: zero-downtime migration standards, schema versioning automation, blue-green deployment integration. Develops platform tools for safe migration execution with automatic rollback.
Database Optimization 2
▼
Creates basic B-tree indexes in PostgreSQL for Go services, understands the difference between regular and unique indexes. Uses EXPLAIN to verify index usage in queries generated by the Go application via pgx/sqlx.
Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses sqlx/GORM effectively.
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.
Shapes organizational database indexing standards: automatic missing index analysis, index usage monitoring policies, capacity planning tools. Develops platform tools for automatic index problem detection.
Writes efficient SQL queries for Go services, avoiding N+1 problems when working with GORM or sqlx. Uses EXPLAIN to understand execution plans, applies parameterized queries and basic pagination via LIMIT/OFFSET.
Independently designs schemas and optimizes queries. Understands indexing and query execution plans. Uses sqlx/GORM effectively.
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 platform query optimization strategy: automatic query regression monitoring, acceptable latency standards for various SLAs. Develops automatic query analysis and optimization tools for all Go services in the organization.
gRPC 1
▼
Uses generated protobuf clients and servers in Go projects. Understands basic .proto file structure, protobuf data types, code generation via protoc-gen-go and protoc-gen-go-grpc. Implements simple unary RPC methods.
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.
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.
Shapes organizational inter-service communication strategy via gRPC: unified proto-registry, API evolution standards, platform protoc plugins. Develops shared gRPC libraries with tracing, circuit breaker, and automatic client generation.
Memory Management 1
▼
Understands the fundamentals of Memory Management at a basic level. Applies simple concepts in work tasks using Go. Follows recommendations from senior developers when solving problems.
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.
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.
Defines memory management strategy for high-load Go services: GOGC/GOMEMLIMIT policies, object pool standards, off-heap storage via mmap. Develops platform tools for memory footprint monitoring and automatic leak alerting.
Message Queues & Event Streaming 3
▼
Uses Apache Kafka at a basic level with gin/echo/fiber. Performs simple tasks using existing templates. Understands basic concepts and follows team-adopted practices.
Independently implements Apache Kafka tasks in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.
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.
Defines event-driven architecture strategy on Kafka for the entire Go platform: streaming processing standards, retention policies, multi-cluster replication. Designs platform SDK in Go for unified Kafka interaction, including tracing via OpenTelemetry.
Understands message broker patterns in Go: pub-sub, fan-out, and work queues with channels and goroutines. Follows team conventions for integrating with NATS, Kafka, or RabbitMQ using Go client libraries.
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.
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.
Shapes Go event-driven architecture strategy: designs multi-datacenter messaging with eventual consistency guarantees, defines event versioning and schema migration patterns. Influences streaming platform architecture with Kafka/Pulsar/NATS for processing millions of events per second.
Uses NATS / NATS JetStream at a basic level with gin/echo/fiber. Performs simple tasks using existing templates. Understands basic concepts and follows team-adopted practices.
Independently implements tasks with NATS / NATS JetStream in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.
Makes architectural decisions on NATS / NATS JetStream at the product level. Defines standards. Conducts design reviews and determines the technical roadmap.
Defines NATS / NATS JetStream strategy at the company level. Evaluates new technologies and approaches. Establishes enterprise standards and reference architectures.
Microservices Patterns 1
▼
Understands basic architectural concepts of microservices decomposition. Follows team's architectural decisions. Understands main patterns.
Participates in Go monolith decomposition into microservices: identifies bounded contexts, designs API contracts via protobuf, implements inter-service communication through gRPC. Understands monolith vs microservices trade-offs, applies strangler fig pattern.
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 organizational microservice architecture strategy in Go: service size standards, team topology, platform-as-product approach. Develops governance framework for microservices, defines architecture health metrics and evolution policies.
NoSQL Databases 1
▼
Executes basic analytical queries to ClickHouse from Go using the clickhouse-go driver. Understands the columnar storage model, uses simple SELECT with aggregations and filtering by partitioned columns for efficient queries.
Independently designs schemas and optimizes queries with ClickHouse. Understands indexing and query execution plans. Uses sqlx/GORM effectively.
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.
Defines organizational analytics warehouse strategy on ClickHouse: cluster configuration, retention and tiered storage policies, Go service integration via shared SDKs. Develops data modeling standards for OLAP scenarios.
Relational Databases 1
▼
Executes basic SQL queries to PostgreSQL from Go services via pgx or database/sql. Understands PostgreSQL data types, writes simple SELECT/INSERT/UPDATE with parameterized queries for SQL injection protection.
Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses sqlx/GORM effectively.
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.
Defines PostgreSQL strategy for the entire Go platform: schema design standards, partitioning and archival policies, multi-region replication. Develops platform abstractions for PostgreSQL including automatic failover and observability.
REST API 1
▼
Creates simple REST endpoints in Go using Gin or Chi: handling GET/POST requests, parsing JSON via encoding/json, returning correct HTTP status codes. Follows basic REST naming conventions for resources and uses middleware for logging.
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.
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.
Shapes organizational API design strategy for Go platform: REST/gRPC standards, unified API gateway, platform middleware libraries. Develops SDKs for internal and external API consumers, defines SLAs and backward compatibility policies.
System Design 1
▼
Understands basic principles of high-load Go systems: concurrent processing via goroutines, connection pooling for PostgreSQL/Redis, HTTP server with configured timeouts. Studies scaling patterns and monitoring via Prometheus client_golang.
Implements high-load Go service components: worker pools via goroutines and channels, caching with ristretto/Redis, rate limiting. Applies graceful degradation through circuit breakers, configures pprof for load profiling and benchmarking.
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).
Shapes organizational strategy for building high-load systems in Go: reference architectures, scaling standards, platform libraries. Defines technology radar for Go stack, coordinates cross-team optimizations and capacity planning.
Web Frameworks 1
▼
Uses Go Web Frameworks at a basic level with gin/echo/fiber. Performs simple tasks using existing templates. Understands basic concepts and follows team-adopted practices.
Independently implements tasks with Go Web Frameworks in gin/echo/fiber. Understands internals and optimizes performance. Writes tests using go test.
Makes architectural decisions on Go Web Frameworks at the product level. Defines standards. Conducts design reviews and determines the technical roadmap.
Defines Go Web Framework strategy at the company level. Evaluates new technologies and approaches. Establishes enterprise standards and reference architectures.