AI Coding Assistants 1
▼
Uses GitHub Copilot for writing Go code: function autocompletion, generating table-driven tests from signatures, creating SQL queries for pgx/sqlx. Critically evaluates Copilot suggestions for Go code idiomacy and correct error handling.
Effectively uses Copilot in Go projects: middleware generation for Gin/Chi, boilerplate for gRPC services, data structure conversions. Uses Copilot Chat for explaining complex concurrent code, documentation generation, and refactoring.
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.
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.
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Application Security 1
▼
Follows secure coding practices in Go: parameterized SQL queries, input escaping, secure password handling via bcrypt (golang.org/x/crypto). Does not store secrets in code, uses environment variables via os.Getenv.
Applies advanced secure Go coding practices: crypto/rand for token generation, constant-time comparison for secrets, secure serialization. Configures TLS in net/http servers, implements input sanitization and output encoding, applies the principle of least privilege.
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.
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.
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.
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 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.
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.
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.
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.
CI/CD 1
▼
Creates basic GitHub Actions workflows for Go projects: go build, go test, go vet on every pull request. Configures Go module caching via actions/cache, uses Go matrix strategy for testing across different Go versions.
Develops CI/CD pipeline in GitHub Actions for Go: parallel stages for lint (golangci-lint), test, build, Docker build. Configures code coverage via coveralls, integration tests with testcontainers-go, and automatic deployment to staging.
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.
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.
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.
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.
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.
Cloud Providers 1
▼
Uses basic AWS services for Go applications: S3 for file storage via aws-sdk-go-v2, SQS for message queues, CloudWatch for logs. Understands IAM roles, configures local testing with LocalStack and docker-compose.
Integrates Go services with AWS: ECS/Fargate for containers, RDS PostgreSQL, ElastiCache Redis, SNS/SQS for events. Uses aws-sdk-go-v2 with retry policies and context for timeouts, configures CloudWatch metrics via embedded metrics format.
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.
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.
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 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 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.
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.
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.
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.
Containerization 1
▼
Writes basic Dockerfiles for Go applications: multi-stage builds with golang:alpine for the build stage and scratch/distroless for the final image. Understands layer caching, copying go.mod/go.sum before source code, and running via docker-compose for local development.
Optimizes Docker images for Go services: multi-stage build with CGO_ENABLED=0 for static linking, minimal scratch images sized 10-20MB. Configures docker-compose for local environment with PostgreSQL, Redis, Kafka and health checks via Go endpoints.
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.
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.
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.
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.
Defines data modeling standards for the Go platform: naming conventions, partitioning policies, multi-tenant data strategies. Reviews team data architecture, ensuring consistency across microservices.
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.
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 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.
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.
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.
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.
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.
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.
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.
Distributed Tracing 1
▼
Integrates basic OpenTelemetry into Go services: connects otel SDK, configures trace exporter (Jaeger/OTLP), adds spans for HTTP handlers. Understands concepts of traces, spans, context propagation and uses ready-made instrumentation libraries for Gin/gRPC.
Configures OpenTelemetry for Go microservices: auto-instrumentation for HTTP/gRPC/SQL via otel contrib, custom spans for business logic, baggage propagation. Implements trace-log-metric correlation, configures sampling strategies and batch processing.
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.
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.
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.
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.
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.
Kubernetes & Orchestration 1
▼
Deploys Go services to Kubernetes: writes basic Deployment and Service manifests, configures liveness/readiness probes via Go application HTTP endpoints. Uses kubectl to view logs, pod status, and basic debugging.
Configures Kubernetes resources for Go services: ConfigMap/Secret for configuration via envconfig, HPA for autoscaling by CPU/memory, Ingress for routing. Implements graceful shutdown in Go via signal.NotifyContext for proper termination on SIGTERM.
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.
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.
Logging 1
▼
Uses structured logging in Go services via zerolog or zap: logging with fields (request_id, user_id, method), log levels (debug, info, error). Understands JSON log format for ELK/Loki integration and adds contextual information to log entries.
Configures structured logging for Go microservices: middleware for automatic HTTP/gRPC request logging, request_id propagation via context.Context. Implements centralized level configuration through zerolog/zap, sensitive data filtering, and log sampling.
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.
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.
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.
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.
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.
Message Queues & Event Streaming 2
▼
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.
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.
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.
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.
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.
Makes architectural decisions on NATS / NATS JetStream at the product level. Defines standards. Conducts design reviews and determines the technical roadmap.
Metrics & Monitoring 1
▼
Adds basic Prometheus metrics to Go services via client_golang: counters for requests, histograms for latency, gauges for active connections. Understands /metrics exposition format, creates simple Grafana dashboards for monitoring key indicators.
Configures comprehensive Go service monitoring: RED metrics (Rate, Errors, Duration) via promauto, custom business metrics, SLI/SLO. Creates Grafana dashboards with variables for multi-service monitoring, configures alerting via Alertmanager.
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 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.
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.
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.
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.
Networking 1
▼
Understands basic networking concepts for Go development: HTTP/HTTPS, DNS resolution, TCP/UDP. Uses net/http client with timeouts, understands Docker networks for container communication in docker-compose and basic request routing.
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.
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.
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.
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 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.
OOP & Design Patterns 2
▼
Understands the fundamentals of Design Patterns at a basic level. Applies simple concepts in work tasks using Go. Follows recommendations from senior developers when solving problems.
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.
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.
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.
Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using Go. Follows recommendations from senior developers when solving problems.
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.
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.
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.
Optimization 1
▼
Understands main sources of latency in Go services: network calls, SQL queries, serialization. Applies basic optimizations: configuring timeouts via context.WithTimeout, connection pooling for PostgreSQL/Redis, using sync.Pool for reusable objects.
Optimizes Go service latency: parallel requests via errgroup, caching through ristretto/Redis, async processing via goroutines. Profiles latency through pprof trace, optimizes JSON serialization via easyjson/sonic, configures HTTP keep-alive.
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.
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.
Profiling 1
▼
Uses basic Go profiling tools: go test -bench for benchmarks, net/http/pprof for collecting CPU profiles from a running service. Reads flame graphs via go tool pprof, identifies hottest functions and understands basic CPU time metrics.
Profiles Go services via pprof: CPU, goroutine, block profiling through HTTP endpoint. Analyzes flame graphs and top functions, optimizes hot paths, compares pre/post-optimization profiles via pprof diff. Uses go test -benchmem for allocation analysis.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Designs solutions based on Go Web Frameworks for production systems. Optimizes performance and scalability. Chooses between alternative approaches. Mentors the team.
Makes architectural decisions on Go Web Frameworks at the product level. Defines standards. Conducts design reviews and determines the technical roadmap.