-
Phase 1. Where to start
Why this course exists and who it fits: the problem it solves, how phases, quizzes, tests and trainers work, and how to go through it without dropping off.
- Зачем этот курс required
-
Phase 2. Language basics: Python · 19 questions
Syntax and types, data structures, functions and modules, OOP, exceptions, generators, type annotations, tooling — language foundations before frameworks.
-
Phase 3. Algorithms and data structures · 107 questions
Arrays and Big-O, sorting, stacks and queues, lists, recursion, trees, hash tables, heaps and graphs — the foundation under collections, indexes and stores.
- Why data structures and algorithms matter
- Math behind big O: logarithms, powers and growth rates required
- Arrays and binary search: big-O notation, ArrayList and Arrays.binarySearch required
- Simple sorting: bubble, selection, insertion required
- Stacks and queues: LIFO, FIFO, circular queue and ArrayDeque
- Linked Lists: Nodes, References and Why LinkedList Loses to ArrayList
- Recursion: base case, call stack and divide and conquer required
- Advanced sorting: Shell sort, quicksort and radix sort
- Binary search trees: the rule, traversal, deletion and TreeMap
- Red-black trees: rotations, recoloring and TreeMap
- 2-3-4 trees and B-trees: multi-key nodes and database indexes
- Hash tables: hash function, collisions and load factor required
- Heaps: weak ordering, sift up and sift down, PriorityQueue
- Graphs: vertices, edges, DFS and BFS
- Weighted graphs: minimum spanning tree and shortest path
- Two pointers and the sliding window required
- Prefix sums: a range sum as the difference of two numbers required
- Binary search on the answer: monotonicity, bounds and the loop invariant required
- Monotonic stack: next greater element in a single pass required
- Dynamic programming: overlapping subproblems, memoisation and tables required
- Backtracking: the search tree, undoing state, pruning dead branches required
- Choosing a data structure: array, list, tree or hash table required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 4. Git and branching models · 50 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
- Phase test in the cabinet
-
Phase 5. Foundation: FastAPI core · 18 questions
Structure and configuration, Depends, routing, Pydantic, async, middleware and errors, background tasks, persistence with SQLAlchemy.
-
Phase 6. SQL from scratch · 67 questions
The query language before any particular database: tables and keys, SELECT and WHERE, joins, aggregates, NULL, subqueries, window functions, dates and strings, modifying data, creating tables and why a query suddenly got slow.
- What a Database and Tables Are required
- SELECT: Pick, Filter, Sort required
- JOIN: Combine Data from Several Tables required
- Aggregates: COUNT, GROUP BY and HAVING required
- NULL and Data Types: Where Everyone Stumbles required
- Subqueries and CTEs: A Query Inside a Query required
- Window Functions: Counting Without Collapsing Rows
- Даты и время
- Строки
- INSERT, UPDATE, DELETE and Transactions required
- Database Schema: Tables, Keys and Views
- Why a Query Is Slow: Indexes on Your Fingers required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 7. PostgreSQL: model and operations · 21 questions
ACID and isolation, partitioning and sharding of a relational store.
-
Phase 8. Other stores: documents, search, files, analytics · 173 questions
First the foundations — storage engines, replication, sharding, streams. Then the stores themselves: MongoDB, Elasticsearch, S3 object storage and analytical ClickHouse.
- 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
- 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
- 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
- Cassandra Architecture: a Ring With No Leader Node
- Cassandra Data Model: Partition Key and Clustering Columns
- Consistency and Replication in Cassandra: Tunable per Request
- How Neo4j Works: the Property Graph, Nodes, Relationships and Index-Free Traversal
- Cypher: a Graph Query Language in Plain Words
- Neo4j graph modeling: indexes, supernodes and operations
- 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
- Neo4j: применение
- PostgreSQL or ClickHouse: when to add a second database
- Search: PostgreSQL FTS or Elasticsearch
- Files: in the database or in object storage
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 9. Design principles and patterns · 35 questions
SOLID, all 23 GoF patterns, GRASP and DRY/KISS/YAGNI with examples.
-
Phase 10. Networking fundamentals · 44 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
- Два пула: БД и HTTP
- Load Balancers and Reverse Proxies required
- Networking and Reliability: Timeouts, Retries, Idempotency
- Диагностика сети
- WebSocket, SSE and long polling required
- WebSocket: много подов
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 11. API: REST and contracts · 60 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
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 12. Security and authorization · 33 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
- Phase test in the cabinet
-
Phase 13. Brokers and distributed systems · 42 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
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 14. Microservices: architecture and pitfalls · 32 questions
Whether you need microservices, how a service is structured and how they communicate; what breaks in a distributed system and how to fix it — saga, outbox, idempotency, resilience.
- Choosing your starting architecture: monolith, modular monolith, microservices required
- Structural Patterns for Microservices in Python
- Between services: synchronous call or events 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
- Correctness in a distributed system in plain words: the end-to-end argument, exactly-once, integrity versus timeliness
- Distributed patterns: data consistency across services in Python
- Resilience Patterns: Retry, Circuit Breaker, Bulkhead, DLQ in Python
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 15. Kubernetes and graceful shutdown · 48 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
- Helm
- Argo CD
- 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
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 16. Clouds · 261 questions
Cloud principles and three providers — AWS, Azure and GCP: networking, IAM, compute, scaling, serverless, data, storage and IaC. One model, knowledge transfers between clouds.
- Что такое облако required
- Регионы и зоны required
- Учётные записи и права required
- Сеть required
- Вычисления required
- Управляемые данные required
- Наблюдаемость и секреты required
- Деньги required
- Отказоустойчивость required
- 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
- Основы
- Сеть
- Entra ID и RBAC
- Где запускать сервис
- Масштабирование и доступность
- Serverless
- Управляемые данные
- Cosmos DB
- Blob Storage
- Из Spring Boot
- Безопасность и наблюдаемость
- Оптимизация затрат
- Отказоустойчивость и DR
- Инфраструктура как код
- Основы
- Сеть
- Cloud IAM
- Где запускать сервис
- Масштабирование и доступность
- Serverless
- Управляемые данные
- Firestore и NoSQL
- Cloud Storage
- Из Spring Boot
- Безопасность и наблюдаемость
- Оптимизация затрат
- Отказоустойчивость и DR
- Terraform
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 17. CI/CD: the delivery pipeline · 25 questions
Pipeline principles, release strategies, branching and delivery.
-
Phase 18. Quality: test strategy · 16 questions
The test pyramid, slices and integration tests, mocks and external services, load testing.
-
Phase 19. Observability and diagnostics · 33 questions
How to see what a running system is doing: logs, metrics, tracing, context propagation, health checks, SLOs and alerts — plus database diagnostics and the incident review afterwards.
- Наблюдаемость
- 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
- Постмортем и дежурства required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 20. Working with AI agents · 79 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 required
- AI Hallucinations: Why the Model Confidently Makes Things Up required
- Tokens and Cost: What You Pay For When Working With AI
- Context: What the Model Holds in Mind at Once required
- Tool Calling: How the Model Reaches Beyond Text required
- Agents: A Model in a Loop with Tools and a Goal required
- Working with Agents: The Basic Loop of a Productive Session required
- Команды Claude Code required
- Spec-driven development
- Reviewing and Testing Code with an Agent
- Accepting AI output: acceptance criteria and tests from the spec required
- AI as the product engineer's leverage required
- Configuring an agent for your project: rules, memory, tools required
- Which Programming Language to Choose for AI Coding
- Daily work with an agent: understand, build, fix required
- How to Review Code Written by AI required
- Executable agent rules vs SonarQube vs ESLint vs tech lead review
- Phase test in the cabinet
-
Phase 21. Building LLM applications · 16 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.
-
Phase 22. System design and architectural choices · 50 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
- How a Notification System Works: Architecture From Scratch
- How to write and defend a system design: design doc, C4, review required
- ADR: how to record architecture decisions required
- The Architect's Role in a Development Team required
- C4 model
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 23. Domain-Driven Design · 39 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
- Phase test in the cabinet
-
Phase 24. Service architecture patterns · 45 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
- Batch Data Processing: How Not to Break Your Background Worker in Python
- Event Sourcing: Store Events, Not State
- Phase test in the cabinet
-
Phase 25. Development methodologies and process · 41 questions
Waterfall, Agile, Scrum, Kanban, XP, estimation and scaling — how a team organizes work from idea to release.
- Development Models: From Waterfall to Agile required
- Scrum: Roles, Events, and Artifacts required
- Kanban: Flow, WIP Limits, and Pull required
- Extreme Programming: the Engineering Practices of Agile
- Estimation and planning: story points and velocity
- Scaling Agile: SAFe and LeSS
- A Methodology for AI: Use Case Pattern and Other Ways
- Phase test in the cabinet
Программа обучения v11.1.72
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 1354 self-check questions in total.