-
Phase 1. Language basics: Go · 8 questions
Syntax, structs and methods, interfaces, slices and maps, errors, goroutines and channels, pointers, tooling — language foundations before backend plumbing.
- Синтаксис и типы
- Структуры и методы
- Интерфейсы
- Срезы и map
- Ошибки
- Горутины и каналы
- Указатели
- Инструменты Go
Take the phase quiz → self-check after reading the phase
-
Phase 2. Algorithms and data structures · 12 questions
Arrays and Big-O, sorting, stacks and queues, lists, recursion, trees, hash tables, heaps and graphs — the foundation under collections, indexes and stores.
- Введение
- Массивы и O-нотация
- Простая сортировка
- Стеки и очереди
- Связанные списки
- Рекурсия
- Быстрая сортировка
- Двоичные деревья
- Красно-чёрные деревья
- Хеш-таблицы
- Пирамиды (кучи)
- Графы
- Взвешенные графы
- Как выбрать
Take the phase quiz → self-check after reading the phase
-
Phase 3. Git and branching models · 8 questions
Snapshots and commits, branches and merging, push/pull, pull requests and code review, rebase and reflog, branching models from Git Flow to trunk-based.
- What Git is and why everyone needs it required
- Commits and history: add, commit, log, and .gitignore required
- Branches and merging: merge and conflicts required
- Remote repositories: push, pull, and fetch required
- Pull requests and code review required
- Rebase and cherry-pick: rewriting history
- Undo and recovery: reset, revert, reflog
- Branching models: Git Flow, GitHub Flow, trunk-based
Take the phase quiz → self-check after reading the phase
-
Phase 4. Go as the foundation · 8 questions
The core Go stack: structure and wiring, chi and net/http, JSON, validation, middleware, context, errors, sqlc+pgx, concurrency.
- Структура и проводка
- Роутинг (chi)
- Обработчики и JSON
- Валидация
- Middleware
- Context и отмена
- Ошибки и HTTP
- sqlc и pgx
- Конкурентность и shutdown
Take the phase quiz → self-check after reading the phase
-
Phase 5. Data: PostgreSQL · 2 questions
Relational fundamentals: ACID and isolation levels, partitioning and sharding.
- ACID and Transaction Isolation Levels in PostgreSQL required
- Partitioning and Sharding in PostgreSQL
Take the phase quiz → self-check after reading the phase
-
Phase 6. Other stores: documents, search, files, analytics · 8 questions
MongoDB, Elasticsearch, object storage (S3) and ClickHouse for specialized workloads.
- ACID, read and write concerns, transactions in MongoDB in Go
- Replication and Sharding in MongoDB
- Document modeling in MongoDB: embed vs reference, indexes required
- Elasticsearch: how a search engine works required
- How Queries Work in Elasticsearch and Why Documents Are Ranked the Way They Are required
- How Elasticsearch works in production: ILM, snapshots, sizing, monitoring
- What object storage is: bucket, object, key, storage classes and presigned URL required
- S3 in production: backups, replication, cost, and monitoring
- How ClickHouse Works: Columnar Storage, MergeTree, and OLAP required
- ClickHouse: schema modeling, queries, materialized views required
- ClickHouse in production: replication, TTL, backups and monitoring
- Архитектура
- Модель данных
- Согласованность и репликация
Take the phase quiz → self-check after reading the phase
-
Phase 7. Design principles and patterns · 5 questions
SOLID, GoF, GRASP and the DRY/KISS/YAGNI principles with examples.
- SOLID: five principles of design in Go
- GoF Patterns: All 23 in Plain Words in Go
- GRASP: Assigning Responsibilities in Go
- DRY, KISS, YAGNI and other engineering principles in Go
- Clean Code: names, functions, comments
Take the phase quiz → self-check after reading the phase
-
Phase 8. Networking fundamentals · 8 questions
OSI and TCP/IP models, IP and ports, TCP/UDP, DNS, HTTP and HTTPS, HTTP versions, connections and reliability.
- How Networking Works: The OSI and TCP/IP Models required
- IP Addresses, Ports, and NAT
- TCP and UDP: Reliability vs Speed required
- DNS: How a Domain Name Turns Into an Address required
- HTTP: Methods, Status Codes, Headers required
- HTTPS and TLS: Encryption and the Handshake required
- HTTP/1.1, HTTP/2, and HTTP/3: What Changed
- Connections: Keep-Alive, Pools, and Timeouts
- Load Balancers and Reverse Proxies required
- Networking and Reliability: Timeouts, Retries, Idempotency
- WebSocket, SSE and long polling required
Take the phase quiz → self-check after reading the phase
-
Phase 9. API: REST and contracts · 8 questions
REST contracts in Go: URLs and resources, parameters, responses, errors, versioning, OpenAPI.
- URLs and Resources in a Go REST API — kebab-case, Nesting, chi
- Query Parameters — Filtering, Pagination, Sorting in Go
- JSON and Response Format in a Go REST API
- REST API Errors in Go — RFC 9457, ProblemDetails, Validation
- HTTP headers in Go: standard, custom, and tracing
- REST API Versioning in Go: /api/v1 and breaking changes
- Alias and Action Endpoints in Go — me, latest, and Domain Commands
- OpenAPI and Common Mistakes in REST APIs on Go
- Rate limiting, files, deprecation in a Go REST API
- Batch operations, long-running tasks and error localization in Go
Take the phase quiz → self-check after reading the phase
-
Phase 10. Security and authorization · 10 questions
Auth in Go and authorization patterns: where checks live, JWT, RBAC/ABAC, secrets and auditing.
- Аутентификация
- Authentication and authorization patterns
- Which Check Goes Where — Gateway, BFF, and Domain Service (Go)
- JWT validation in Go: golang-jwt and JWKS
- RBAC in Go: Roles from JWT and Checking in chi Middleware
- ABAC and Resource Ownership in Go
- Storing Tokens on the Client — HttpOnly Cookies and Refresh Rotation (Go)
- Service-to-Service Authentication in Go — mTLS and Client Credentials
- PII and Secrets in Go — What Must Not Go into slog, error, and Kafka
- Administrator Action Journal in Go
- PCI DSS for developers
- GDPR for Developers
Take the phase quiz → self-check after reading the phase
-
Phase 11. Brokers and distributed systems · 7 questions
AMQP/RabbitMQ, Kafka and distributed patterns: saga, outbox, idempotency.
- The AMQP protocol: exchange, queue, binding, ack required
- RabbitMQ in production: clustering, queue types and monitoring
- Messaging Patterns with AMQP in Go
- AMQP vs Kafka: which broker to choose required
- Apache Kafka: topics, partitions, ordering and guarantees in Go
- Kafka in production in Go: kafka-go, DLQ, Schema Registry, tuning, security
- Distributed patterns: data consistency across services in Go
Take the phase quiz → self-check after reading the phase
-
Phase 12. Kubernetes and graceful shutdown · 9 questions
Cluster, networking, Kubernetes deployment and operations, plus graceful service shutdown.
- Kubernetes: pod, deployment, service — where to start required
- Networking in Kubernetes: Service, DNS, Ingress, NetworkPolicy required
- Deploying to Kubernetes: manifests, Helm, rolling update, GitOps required
- Kubernetes in practice: debugging pods and kubectl commands
- OpenShift: How It Differs from Vanilla Kubernetes
- Go: server configuration and readiness during graceful shutdown
- HTTP drain in Go — how to correctly stop an HTTP server
- Database and persistence during graceful shutdown of a Go service
- Background goroutines and the outbox-relay during graceful shutdown in Go
- Kafka shutdown in Go: stopping the consumer and producer without losing messages
- Idempotency of in-flight operations in Go
- Kubernetes and graceful shutdown in Go: terminationGracePeriodSeconds, probes, rolling update
- Shutdown budgets and observability in Go
Take the phase quiz → self-check after reading the phase
-
Phase 13. Clouds · 8 questions
The cloud model across four providers — AWS, Yandex Cloud, Azure and GCP: networking, IAM, compute, scaling, serverless, data, storage and IaC. One model, knowledge transfers between clouds.
- AWS Fundamentals: Accounts, IAM, Regions, and VPC required
- Networking in AWS: VPC, subnets, NAT and security groups required
- IAM in AWS: Users, Roles, and Policies required
- Where to run a service in AWS: EC2, ECS, EKS or Lambda required
- Scaling and Availability in AWS required
- Serverless on AWS: Lambda, events, cold start, API Gateway required
- Managed Data in AWS: RDS, ElastiCache, SQS, MSK required
- DynamoDB: keys, indexes, and when to pick it over SQL
- Security and observability in AWS: Secrets Manager, SSM, KMS, CloudWatch required
- AWS cost optimization: where to start
- Resilience and Disaster Recovery in AWS
- AWS Well-Architected Framework: six pillars and how to use them required
- Infrastructure as Code: the basics
- Terraform: HCL, Providers, State, and Modules
- CloudFormation: Templates and Stacks
- AWS CDK: infrastructure as a program
- IaC in Practice: State, Secrets, Delivery
- Основы
- Сеть
- Cloud IAM
- Где запускать сервис
- Масштабирование и доступность
- Serverless
- Управляемые данные
- YDB
- Object Storage
- Из Spring Boot
- Безопасность и наблюдаемость
- Оптимизация затрат
- Отказоустойчивость и DR
- Terraform
- Основы
- Сеть
- Entra ID и RBAC
- Где запускать сервис
- Масштабирование и доступность
- Serverless
- Управляемые данные
- Cosmos DB
- Blob Storage
- Из Spring Boot
- Безопасность и наблюдаемость
- Оптимизация затрат
- Отказоустойчивость и DR
- Инфраструктура как код
- Основы
- Сеть
- Cloud IAM
- Где запускать сервис
- Масштабирование и доступность
- Serverless
- Управляемые данные
- Firestore и NoSQL
- Cloud Storage
- Из Spring Boot
- Безопасность и наблюдаемость
- Оптимизация затрат
- Отказоустойчивость и DR
- Terraform
Take the phase quiz → self-check after reading the phase
-
Phase 14. CI/CD: the delivery pipeline · 3 questions
Pipeline principles, release strategies, branching and delivery.
- CI/CD principles: the pipeline from commit to production required
- Release strategies: rolling, blue-green, canary, feature flags required
- Branching and the release cycle: trunk-based, versions, GitOps
Take the phase quiz → self-check after reading the phase
-
Phase 15. Quality: testing and observability · 9 questions
Testing and observability in Go.
- Тестирование
- Наблюдаемость
- Logging in Go: slog, JSON and context.Context
- Metrics in Go: prometheus/client_golang, RED, USE and business counters
- Distributed tracing in Go: OpenTelemetry from scratch
- Context propagation in Go — context.Context, middleware and goroutines
- Health checks in Go: liveness, readiness and /info
- SLO and alerts in Go: error budget and multi-window burn rate
- Observability configuration in Go: management port, logs and metrics
- Load testing: k6, Gatling, JMeter required
Take the phase quiz → self-check after reading the phase
-
Phase 16. Working with AI agents · 9 questions
How a language model works and how to write code productively with an AI agent: tokens and hallucinations, context, tool calling, agents, the working loop, reviewing and accepting AI code.
- How AI Models Work: Predicting the Next Token
- AI Hallucinations: Why the Model Confidently Makes Things Up
- Tokens and Cost: What You Pay For When Working With AI
- Context: What the Model Holds in Mind at Once
- Tool Calling: How the Model Reaches Beyond Text
- Agents: A Model in a Loop with Tools and a Goal
- Working with Agents: The Basic Loop of a Productive Session
- Reviewing and Testing Code with an Agent
- Accepting AI output: acceptance criteria and tests from the spec
Take the phase quiz → self-check after reading the phase
-
Phase 17. Building LLM applications · 6 questions
How to embed AI into a backend product: what an LLM feature is made of, orchestration with LangChain, RAG and embeddings, vector databases, and agent applications.
- What an LLM feature is made of
- LangChain: orchestrating LLM applications
- RAG and embeddings: giving the model your data
- Vector databases
- Agent applications: tools and autonomous loops
Take the phase quiz → self-check after reading the phase
-
Phase 18. System design and architectural choices · 21 questions
The design method, building blocks and choices around storage, synchronicity and notations.
- Reliability, scalability, maintainability — in plain words required
- The system design method: from requirements to architecture required
- Building Blocks of System Design required
- B-trees and LSM-trees in plain words: how a database stores data required
- OLTP and OLAP in plain words: two different worlds of working with data required
- Schema evolution in plain words: changing data formats without breaking anything
- Replication models in plain words: why a replica lags, multi-leader, and quorums required
- Partitioning (sharding) in plain words: slicing data across nodes without a hot spot required
- The trouble with distributed systems in plain words: partial failures, unreliable clocks, truth by quorum required
- Consistency and consensus in plain words: linearizability, CAP, and one shared problem required
- System of record and derived data in plain words: why a cache, an index, and a read model are the same thing
- Stream processing in plain words: change data capture (CDC) and time in streams
- Correctness in a distributed system in plain words: the end-to-end argument, exactly-once, integrity versus timeliness
- How a Notification System Works: Architecture From Scratch
- How to write and defend a system design: design doc, C4, review required
- Choosing your starting architecture: monolith, modular monolith, microservices required
- PostgreSQL or MongoDB: how to choose a database
- Oracle or PostgreSQL: differences and migration
- Cassandra, PostgreSQL or MongoDB: when to reach for a wide-column NoSQL
- Graph data in plain words: recursive SQL or a graph database
- PostgreSQL or ClickHouse: when to add a second database
- Search: PostgreSQL FTS or Elasticsearch
- Files: in the database or in object storage
- Between services: synchronous call or events required
- ADR: how to record architecture decisions required
- The Architect's Role in a Development Team required
- C4 model
Take the phase quiz → self-check after reading the phase
-
Phase 19. Domain-Driven Design · 7 questions
Strategic and tactical patterns, integration and domain design principles.
- What DDD Is and Why You Need It required
- Strategic DDD Patterns in Go
- DDD Tactical Patterns in Go
- DDD Integration Patterns in Go
- Design Principles in DDD in Go
- Ontology and the domain model: a system of concepts before aggregates
- Event Storming: extracting the domain model from the business
Take the phase quiz → self-check after reading the phase
-
Phase 20. Service architecture patterns · 8 questions
Service structure, Onion and Hexagonal, CQRS, resilience and batch processing (in Go).
- Onion Architecture required
- CQRS
- When to apply CQRS in a Go service
- The command side in CQRS with Go
- The query side in CQRS with Go: how to read data properly
- Read-model in CQRS (Go): where to store it and how to update the projection
- Synchronizing the read-model via events in Go
- CQRS tier and evolution in Go
- Hexagonal architecture
- When to Use Hexagonal Architecture in a Go Service
- The Core Layer in Go: Hexagonal Architecture
- Ports in Hexagonal Architecture — How the Core Talks to the Outside World (Go)
- Inbound Adapters in Hexagonal Architecture with Go
- Out Adapters in Hexagonal Architecture in Go
- Hexagonal Architecture Package Structure in Go
- Bootstrap and Composition Root in Hexagonal Architecture (Go)
- Hexagonal Architecture Tests in Go
- Structural Patterns for Microservices in Go
- Resilience Patterns: Retry, Circuit Breaker, Bulkhead, DLQ in Go
- Batch Data Processing: How Not to Break Your Background Worker in Go
- Event Sourcing: Store Events, Not State
Take the phase quiz → self-check after reading the phase
-
Phase 21. Development methodologies and process · 8 questions
Waterfall, Agile, Scrum, Kanban, XP, estimation and scaling — how a team organizes work from idea to release.
- Development Models: From Waterfall to Agile
- Scrum: Roles, Events, and Artifacts
- Kanban: Flow, WIP Limits, and Pull
- Extreme Programming: the Engineering Practices of Agile
- Estimation and planning: story points and velocity
- Scaling Agile: SAFe and LeSS
Take the phase quiz → self-check after reading the phase
Программа обучения v4.6.0
Backend · Go
A Go backend training program: sixteen phases from the Go stack (net/http, chi, sqlc+pgx) through data, design principles and patterns, search, infrastructure, and quality to system design and DDD, culminating in the Use Case Pattern, and finally an end-to-end marketplace case study. The conceptual phases are shared across languages; the tooling ones are Go-specific.
The program has 172 self-check questions in total.