-
Phase 1. Language basics: Python · 8 questions
Syntax and types, data structures, functions and modules, OOP, exceptions, generators, type annotations, tooling — language foundations before frameworks.
- Синтаксис и типы
- Структуры данных
- Функции и модули
- ООП в Python
- Исключения и with
- Итераторы и генераторы
- Аннотации типов
- Инструменты Python
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. Foundation: FastAPI core · 8 questions
Structure and configuration, Depends, routing, Pydantic, async, middleware and errors, background tasks, persistence with SQLAlchemy.
- Структура и конфигурация
- Dependency Injection
- Роутинг и запросы
- Pydantic
- Async и конкурентность
- Middleware и ошибки
- Фоновые задачи
- SQLAlchemy + Alembic
Take the phase quiz → self-check after reading the phase
-
Phase 5. PostgreSQL: model and operations · 2 questions
ACID and isolation, partitioning and sharding of a relational store.
- 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, S3 object storage and analytical ClickHouse.
- ACID, read and write concerns, transactions in MongoDB in Python
- 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, all 23 GoF patterns, GRASP and DRY/KISS/YAGNI with examples.
- SOLID: five principles of design in Python
- GoF Patterns: All 23 in Plain Words in Python
- GRASP: Assigning Responsibilities in Python
- DRY, KISS, YAGNI and other engineering principles in Python
- 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
URLs and resources, parameters, responses, errors, versioning, OpenAPI and anti-patterns.
- URLs and Resources in a REST API with FastAPI
- Query Parameters and Pagination in FastAPI
- JSON and response format in FastAPI: camelCase, dates, enums, and pagination
- Errors in a REST API on FastAPI — the RFC 9457 Problem Details format
- HTTP headers in FastAPI — how to read them, send them, and why you need an Idempotency-Key
- Versioning a REST API with FastAPI: v1, v2, and breaking changes
- Alias and Action Endpoints in FastAPI — me, latest, default and Domain Commands
- OpenAPI in FastAPI and common mistakes when designing REST
- Rate Limiting, File Uploads, and Deprecation in FastAPI
- Batch Operations, Long-Running Tasks and Localization in FastAPI
Take the phase quiz → self-check after reading the phase
-
Phase 10. Security and authorization · 10 questions
FastAPI security, where checks happen, JWT, RBAC/ABAC, secrets, service-to-service and auditing.
- Безопасность
- Authentication and authorization patterns
- Where to Put the Auth Check in FastAPI: Gateway, BFF, or Handler
- JWT validation in FastAPI: PyJWT, JWKS and Response Codes
- RBAC in FastAPI: Roles, Mapping, and Endpoint Protection
- ABAC — Resource Ownership Checks in FastAPI (Python)
- Storing Tokens on the Client — HttpOnly Cookies and Refresh Rotation (Python/FastAPI)
- Service-to-Service Authentication in FastAPI: mTLS and Client Credentials
- PII and Secrets in a Python Service: What Must Not Go into Logs, Responses, and the Queue
- Administrator Action Log in FastAPI
- 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 Python
- AMQP vs Kafka: which broker to choose required
- Apache Kafka in Python: topics, partitions, ordering and guarantees
- Kafka in production in Python: aiokafka, DLQ, Schema Registry, tuning, security
- Distributed patterns: data consistency across services in Python
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
- uvicorn/lifespan configuration — graceful shutdown and readiness in FastAPI
- HTTP drain in FastAPI: how not to lose requests on restart
- SQLAlchemy and the database during FastAPI application shutdown
- asyncio tasks and the outbox relay when a FastAPI application stops
- Kafka shutdown — aiokafka consumer stop and producer flush
- Idempotency of in-flight operations during Python service shutdown
- Kubernetes and FastAPI: how to configure correct service shutdown
- Shutdown budgets and observability in FastAPI
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 with FastAPI.
- Тестирование
- Наблюдаемость
- Logging in Python: structlog, levels, contextvars and protecting personal data
- Metrics in Python — prometheus-client, RED, USE and business indicators
- Distributed tracing in Python: OpenTelemetry from scratch
- Context propagation in FastAPI: request_id, trace_id and user_id in every log
- Health checks in FastAPI: liveness, readiness and /info
- SLO and alerts in Python
- Observability configuration in Python: 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, storage and integration choices, ADR, C4.
- 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, context integration, design principles.
- What DDD Is and Why You Need It required
- Strategic DDD Patterns in Python
- DDD Tactical Patterns in Python
- DDD Integration Patterns in Python
- Design Principles in DDD in Python
- 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 and microservice structure, Onion and Hexagonal, CQRS, resilience and batch processing.
- Onion Architecture required
- CQRS
- When to apply CQRS in a Python service
- Command side in CQRS with Python: how to write commands and handlers
- Query side in CQRS with Python — how to read data correctly
- Read-model in CQRS — a denormalized projection on FastAPI / SQLAlchemy
- How the read-model synchronizes with the write side in CQRS on Python
- CQRS tier and evolution — Python (FastAPI + SQLAlchemy)
- Hexagonal architecture
- When to apply Hexagonal Architecture in Python
- The core layer in Hexagonal Architecture on Python
- Ports in Hexagonal Architecture on Python — how the core talks to the outside world
- Inbound adapters in Hexagonal architecture on Python
- Out-adapters in Hexagonal Python: how a service talks to the outside world
- Package structure in Hexagonal Architecture (Python)
- Bootstrap / Composition Root in Hexagonal (Python)
- Architecture tests in Python: how to keep the layers from mixing
- Structural Patterns for Microservices in Python
- Resilience Patterns: Retry, Circuit Breaker, Bulkhead, DLQ in Python
- Batch Data Processing: How Not to Break Your Background Worker in Python
- 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 · Python
This site is built as a training program, bound to Python and FastAPI. Sixteen phases run from FastAPI fundamentals through data, design principles, 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 program has 172 self-check questions in total.