-
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 · 63 questions
Syntax and types, data structures, functions and modules, OOP, exceptions, generators, type annotations, tooling — language foundations before frameworks.
- Синтаксис и типы required
- Структуры данных required
- Функции и модули required
- ООП в Python required hands-on code
- Исключения и with required
- Итераторы и генераторы required
- Аннотации типов required
- Инструменты Python
- Как Python выполняет код required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 3. Algorithms and data structures · 111 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
- 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 required
- 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
- Binary search on the answer: monotonicity, bounds and the loop invariant
- Monotonic stack: next greater element in a single pass
- Dynamic programming: overlapping subproblems, memoisation and tables
- Backtracking: the search tree, undoing state, pruning dead branches
- Choosing a data structure: array, list, tree or hash table required
- Хвостовая латентность
- Горячий путь
- Order book
- Маркет-дата
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 4. Git and branching models · 51 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
- 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 · 52 questions
Structure and configuration, Depends, routing, Pydantic, async, middleware and errors, background tasks, persistence with SQLAlchemy.
- Структура и конфигурация required hands-on code
- Dependency Injection required hands-on code
- Роутинг и запросы required hands-on code
- Pydantic required hands-on code
- Async и конкурентность required
- Middleware и ошибки hands-on code
- Фоновые задачи
- SQLAlchemy + Alembic required hands-on code
- Django для FastAPI-разработчика
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 6. Async and concurrency · 40 questions
Event loop and coroutines, tasks and cancellation, structured concurrency, synchronization, blocking code and threads, async clients, timeouts and backpressure, debugging, common bugs, tests, the GIL, processes and subinterpreters, asyncio in FastAPI.
- Цикл событий и корутины required
- Задачи и отмена required
- Структурная конкурентность
- Синхронизация required
- Блокирующий код и потоки required
- Асинхронные клиенты
- Таймауты и обратное давление required
- Отладка асинхронного кода
- Ошибки конкурентности required hands-on code
- Тесты асинхронного кода
- Свободные потоки и процессы required
- asyncio во FastAPI required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 7. SQL from scratch · 68 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
- 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 required
- Даты и время
- Строки
- INSERT, UPDATE, DELETE and Transactions
- Database Schema: Tables, Keys and Views required
- Why a Query Is Slow: Indexes on Your Fingers required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 8. PostgreSQL: model and queries · 100 questions
Transactions and isolation, locking, data types, indexes and EXPLAIN.
- ACID and Transaction Isolation Levels in PostgreSQL required hands-on code
- Transaction Isolation Levels in PostgreSQL required
- Locks in PostgreSQL: SELECT FOR UPDATE, SKIP LOCKED and advisory locks required hands-on code
- Naming Objects in PostgreSQL — snake_case, Singular, Prefixes
- Numbers in PostgreSQL: bigint, numeric, boolean and how not to lose money
- String types in PostgreSQL: text, varchar, and char
- Time and Time Zones in PostgreSQL — Why timestamptz and How to Work With It
- UUID in PostgreSQL: the uuid type, v7 vs v4, bigint vs UUID
- Enumerations in PostgreSQL: ENUM, lookup table, or CHECK
- JSONB in PostgreSQL — what it is, how it works, and when to use it
- Arrays and range types in PostgreSQL: tags, bookings, EXCLUDE
- PostgreSQL Index Types — B-tree, GIN, GiST, BRIN required hands-on code
- PostgreSQL Composite Indexes and the Leftmost Prefix Rule required
- Covering Index in PostgreSQL: why you need INCLUDE required
- How to Choose an Index and Estimate Selectivity in PostgreSQL required
- Weights in PostgreSQL full-text search
- EXPLAIN ANALYZE — how to read a PostgreSQL query plan required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 9. PostgreSQL: operations and scale · 98 questions
Migrations, connection pool, vacuum/WAL, replication, backup, partitioning, FTS and geo.
- PostgreSQL migrations with zero downtime required
- Connection pooling in PostgreSQL — HikariCP, PgBouncer and the Wooldridge formula required
- VACUUM, autovacuum and bloat in PostgreSQL required
- WAL in PostgreSQL: what it is and how to control the journal size required
- PostgreSQL replication: read-replica and query routing required
- PostgreSQL Backups: pg_dump, pg_basebackup and PITR
- Partitioning in PostgreSQL: when you need it and how it works required
- Partitioning and Sharding in PostgreSQL
- Multi-tenancy in PostgreSQL: row, schema, db per tenant
- Materialized views in PostgreSQL: how they work and when to use them
- PostgreSQL Triggers and Stored Procedures
- PostgreSQL Extensions: pg_trgm, pgcrypto, pg_stat_statements and Others
- Full-text search in PostgreSQL — tsvector, GIN, russian
- PostGIS: geodata in PostgreSQL — points, polygons, radius search
- Anonymizing a PostgreSQL Dump for a Developer
- Common Mistakes When Choosing Types in PostgreSQL
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 10. SQLAlchemy and ORM · 44 questions
Object-relational mapping in Python: Core and ORM, Mapped models, relationships, session and unit of work, lazy loading and N+1, queries, transactions and locking, AsyncSession, Alembic, performance and common pitfalls.
- ORM и SQLAlchemy required
- Модели и маппинг
- Связи между таблицами
- Сессия и unit of work required hands-on code
- Ленивая загрузка и N+1 required
- Запросы required hands-on code
- Транзакции и блокировки required hands-on code
- Асинхронный SQLAlchemy
- Миграции: Alembic hands-on code
- Производительность
- Типичные грабли
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 11. Other stores: documents, search, files, analytics · 207 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 required
- Replication and Sharding in MongoDB
- Document modeling in MongoDB: embed vs reference, indexes
- Elasticsearch: how a search engine works required
- How Queries Work in Elasticsearch and Why Documents Are Ranked the Way They Are
- elasticsearch-py
- How Elasticsearch works in production: ILM, snapshots, sizing, monitoring
- What object storage is: bucket, object, key, storage classes and presigned URL hands-on code
- boto3
- S3 in production: backups, replication, cost, and monitoring
- What is Redis: an in-memory store for backend developers required
- Redis data structures: String, Hash, List, Set, Sorted Set and more required
- Caching Patterns in Redis required hands-on code
- Redis Is Not Just for Caching: Locks, Rate Limiting, Queues and Pub/Sub required
- redis-py hands-on code
- Operating Redis: persistence, memory, replication required
- How ClickHouse Works: Columnar Storage, MergeTree, and OLAP
- ClickHouse: schema modeling, queries, materialized views
- clickhouse-connect
- 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 12. Design principles and patterns · 37 questions
SOLID, all 23 GoF patterns, GRASP and DRY/KISS/YAGNI with examples.
- SOLID: five principles of design in Python required
- GoF Patterns: All 23 in Plain Words in Python required
- GRASP: Assigning Responsibilities in Python
- DRY, KISS, YAGNI and other engineering principles in Python required
- Clean Code: names, functions, comments
- Low level design interview: solving design-in-code tasks
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 13. Networking fundamentals · 81 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
- Диагностика сети
- Linux for Backend Developers: Processes, Signals, Files and Memory
- WebSocket, SSE and long polling required
- WebSocket: много подов
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 14. API: REST and contracts · 98 questions
URLs and resources, parameters, responses, errors, versioning, OpenAPI and anti-patterns.
- URLs and Resources in a REST API with FastAPI required
- Query Parameters and Pagination in FastAPI hands-on code
- JSON and response format in FastAPI: camelCase, dates, enums, and pagination
- Errors in a REST API on FastAPI — the RFC 9457 Problem Details format required hands-on code
- HTTP headers in FastAPI — how to read them, send them, and why you need an Idempotency-Key required hands-on code
- Versioning a REST API with FastAPI: v1, v2, and breaking changes required
- Alias and Action Endpoints in FastAPI — me, latest, default and Domain Commands
- OpenAPI in FastAPI and common mistakes when designing REST
- API-first подход required
- Rate Limiting, File Uploads, and Deprecation in FastAPI
- Batch Operations, Long-Running Tasks and Localization in FastAPI
- gRPC: Fast Calls Between Services required
- GraphQL: The Client Asks for Exactly What It Needs required
- HATEOAS: REST Maturity and Hyperlinks
- Where to Validate Data required hands-on code
- Свои правила
- Application error model required hands-on code
- Единый обработчик
- Типичные ошибки
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 15. Security and authorization · 160 questions
FastAPI security, where checks happen, JWT, RBAC/ABAC, secrets, service-to-service and auditing.
- Безопасность hands-on code
- Authentication and authorization patterns
- Where to Put the Auth Check in FastAPI: Gateway, BFF, or Handler required
- JWT validation in FastAPI: PyJWT, JWKS and Response Codes hands-on code
- RBAC in FastAPI: Roles, Mapping, and Endpoint Protection
- ABAC — Resource Ownership Checks in FastAPI (Python) hands-on code
- 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 required
- Administrator Action Log in FastAPI hands-on code
- PCI DSS for developers
- GDPR for Developers
- Backend vulnerabilities
- Инъекции
- SSRF
- IDOR и BOLA
- Mass assignment и лишние поля
- Обход пути и загрузки
- XXE и десериализация
- Подбор паролей и лимиты
- Редирект, CSRF и CORS
- Гонки и двойное списание
- Ошибки с JWT
- Как искать уязвимости
- What Keycloak Is and Why You Need It
- OAuth2 and OIDC in plain words required
- Realm, client, roles and users in Keycloak
- Роли и доступ (RBAC/ABAC) required
- Authorization Code Flow and PKCE Step by Step required
- Three Keycloak tokens: access, id, refresh — which goes where required
- Kerberos and LDAP: Enterprise Authentication
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 16. Brokers and distributed systems · 45 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
- NATS messaging: subjects, queue groups and JetStream explained
- NATS vs RabbitMQ vs Kafka: choosing a message broker
- Apache Kafka in Python: topics, partitions, ordering and guarantees required hands-on code
- Kafka in production in Python: aiokafka, DLQ, Schema Registry, tuning, security required hands-on code
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 17. Microservices: architecture and pitfalls · 47 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 hands-on code
- Structural Patterns for Microservices in Python required hands-on code
- Платформа или библиотеки
- 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 required
- Distributed patterns: data consistency across services in Python required hands-on code
- Resilience Patterns: Retry, Circuit Breaker, Bulkhead, DLQ in Python required hands-on code
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 18. Containers: Docker · 60 questions
Containers and images, a Dockerfile for a Python service, multi-stage builds, running containers, volumes and data, networking, Docker Compose, the Python runtime in a container, secure images and registries.
- What Docker and Containers Are required
- Images, layers and the Dockerfile: how Docker packages an application required
- Dockerfile для Python required hands-on code
- Docker Multi-Stage Builds and Layer Caching required
- Running containers: docker run and the lifecycle
- Volumes and data in Docker: how not to lose your database when a container restarts
- Docker Networking: How Containers Talk to Each Other
- Docker Compose: bring up your whole environment with one command required
- Python в контейнере required
- Small and Secure Docker Images
- Image Registries and Building in CI
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 19. Kubernetes and graceful shutdown · 89 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 required
- 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 required
- SQLAlchemy and the database during FastAPI application shutdown
- asyncio tasks and the outbox relay when a FastAPI application stops hands-on code
- Kafka shutdown — aiokafka consumer stop and producer flush
- Idempotency of in-flight operations during Python service shutdown hands-on code
- Kubernetes and FastAPI: how to configure correct service shutdown required
- Shutdown budgets and observability in FastAPI
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 20. 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
- Наблюдаемость и секреты
- Деньги
- Отказоустойчивость
- AWS Fundamentals: Accounts, IAM, Regions, and VPC
- Networking in AWS: VPC, subnets, NAT and security groups
- IAM in AWS: Users, Roles, and Policies
- Where to run a service in AWS: EC2, ECS, EKS or Lambda
- Scaling and Availability in AWS
- Serverless on AWS: Lambda, events, cold start, API Gateway
- Managed Data in AWS: RDS, ElastiCache, SQS, MSK
- DynamoDB: keys, indexes, and when to pick it over SQL
- Security and observability in AWS: Secrets Manager, SSM, KMS, CloudWatch
- AWS cost optimization: where to start
- Resilience and Disaster Recovery in AWS
- AWS Well-Architected Framework: six pillars and how to use them
- 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
- Из приложения
- Безопасность и наблюдаемость
- Оптимизация затрат
- Отказоустойчивость и DR
- Инфраструктура как код
- Основы
- Сеть
- Cloud IAM
- Где запускать сервис
- Масштабирование и доступность
- Serverless
- Управляемые данные
- Firestore и NoSQL
- Cloud Storage
- Из приложения
- Безопасность и наблюдаемость
- Оптимизация затрат
- Отказоустойчивость и DR
- Terraform
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 21. CI/CD: the delivery pipeline · 25 questions
Pipeline principles, release strategies, branching and delivery.
-
Phase 22. Quality: test strategy · 30 questions
The test pyramid, slices and integration tests, mocks and external services, load testing.
- Тестирование required hands-on code
- Интеграционные тесты required
- Моки и внешние системы required
- Load testing: k6, Gatling, JMeter
- The test pyramid: what goes where required
- Phase test in the cabinet
-
Phase 23. Observability and diagnostics · 67 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 required
- Metrics in Python — prometheus-client, RED, USE and business indicators required hands-on code
- Distributed tracing in Python: OpenTelemetry from scratch required
- Context propagation in FastAPI: request_id, trace_id and user_id in every log
- Health checks in FastAPI: liveness, readiness and /info hands-on code
- SLO and alerts in Python
- Observability configuration in Python: management port, logs and metrics
- Профилирование и утечки required
- От алерта до строки лога required
- Постмортем и дежурства required
- PostgreSQL monitoring: slow queries, activity, and key metrics required
- Отчёт нагрузки (pg_profile)
- Запросы для отчёта нагрузки
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 24. Working with AI agents · 81 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 hands-on code
- Agents: A Model in a Loop with Tools and a Goal hands-on code
- Working with Agents: The Basic Loop of a Productive Session
- Команды Claude Code
- Spec-driven development
- Reviewing and Testing Code with an Agent
- Accepting AI output: acceptance criteria and tests from the spec
- AI as the product engineer's leverage
- Configuring an agent for your project: rules, memory, tools
- AI PDLC и MCP
- Which Programming Language to Choose for AI Coding
- Daily work with an agent: understand, build, fix
- How to Review Code Written by AI
- Executable agent rules vs SonarQube vs ESLint vs tech lead review
- Phase test in the cabinet
-
Phase 25. Building LLM applications · 63 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 hands-on code
- LangChain: orchestrating LLM applications
- RAG and embeddings: giving the model your data hands-on code
- Vector databases hands-on code
- Agent applications: tools and autonomous loops hands-on code
- Multi-agent systems: six agent orchestration patterns
- Evaluating AI agents: trajectory tests, rubrics and regressions
- AI agent memory: session state, long-term memory and what to store
- AI agent security: permissions, identity and trust levels
- Инъекция в промпт
- Вывод модели как недоверенный ввод
- Безопасность RAG
- Утечки через модель
- Расход и полномочия модели
- Agents in production: MCP and A2A protocols, deployment and tracing
- Phase test in the cabinet
-
Phase 26. 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
- ADR: how to record architecture decisions required
- The Architect's Role in a Development Team
- C4 model
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 27. Domain-Driven Design · 44 questions
Strategic and tactical patterns, context integration, design principles.
- What DDD Is and Why You Need It required hands-on code
- Strategic DDD Patterns in Python required
- DDD Tactical Patterns in Python required hands-on code
- DDD Integration Patterns in Python required
- 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 28. Service architecture patterns · 105 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 required
- Command side in CQRS with Python: how to write commands and handlers required
- 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 hands-on code
- When to apply Hexagonal Architecture in Python required
- The core layer in Hexagonal Architecture on Python required hands-on code
- Ports in Hexagonal Architecture on Python — how the core talks to the outside world required
- Inbound adapters in Hexagonal architecture on Python
- Out-adapters in Hexagonal Python: how a service talks to the outside world hands-on code
- Package structure in Hexagonal Architecture (Python)
- Bootstrap / Composition Root in Hexagonal (Python)
- Architecture tests in Python: how to keep the layers from mixing hands-on code
- Batch Data Processing: How Not to Break Your Background Worker in Python
- Event Sourcing: Store Events, Not State
- Что это и когда нужны hands-on code
- Реализация на Python hands-on code
- BPM и Camunda
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 29. 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
- 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
-
Phase 30. The product engineer: role and practice · 49 questions
The whole role: start from the user problem, outcome metrics and end-to-end ownership, the domain model and the path from slice to contract.
- Who a Product Engineer Is: The Role and the Work Cycle
- The Problem, Not the Solution
- Contact with the User
- Outcome Metrics, Not Output Metrics
- Prioritization: the smallest valuable slice
- Ownership from idea to user
- Shipping and the Metrics Loop, Solo hands-on code
- The language of the domain: concepts, glossary, knowledge graph
- From a conceptual model to a contract an agent executes
- Phase test in the cabinet
-
Phase 31. Use Case Pattern and the end-to-end case · 66 questions
The culmination: the Use Case Pattern methodology — designing a service from the business task, the Use Case spec, maturity levels 0–3 — and the end-to-end marketplace case that ties the whole path together.
- Use Case Pattern
- Use Case Pattern: a step-by-step guide
- Use Case specification: the format
- Maturity level 0: a snapshot of existing code
- Maturity Level 1: Layered
- Maturity Level 2: UseCase + Handler hands-on code
- Maturity Level 3: DDD + Hexagonal
- Case study: a marketplace — how I understood the task
- How to Split a System into Services: A Marketplace Map
- AI writes the code. So why bother with a methodology?
- The AI-native company: a small team plus agents, and why it still needs a methodology
- Executable engineering standard: an AI agent is your ESLint for architecture
- Phase test in the cabinet
-
Phase 32. JavaScript
Language and runtime foundations: values and references, scope, closures, prototypes, promises, async/await and the event loop.
- JavaScript Essentials required
- Async and the Event Loop in JavaScript required hands-on code
- Types in JavaScript: primitives, objects, and typeof required
- Type coercion: ==, === and truthy/falsy required
- Scope: var, let, const and hoisting required
- Closures: how they work and why you need them required
- Prototypes: delegation and classes as sugar required
- Objects: references, copying, and immutability required
- Promises from the inside: chains, errors, and async/await required
- Iterators and generators
- Mock interview in the cabinet
-
Phase 33. TypeScript
Types and narrowing, generics, classes and decorators, modules, npm and TypeScript tooling.
- TypeScript Basic Types: Annotations, Inference, Union and Any required
- Type Narrowing and Guards in TypeScript required
- Generics in TypeScript: Reusable Type-Safe Code required
- Classes and Decorators in TypeScript required hands-on code
- Modules and npm: how code is assembled from parts
- TypeScript and Node Tooling: Getting Started
- Mock interview in the cabinet
-
Phase 34. The browser and practical CSS
Platform and styling: this, the event loop, DOM, security, critical rendering, errors, animations, bundling and practical CSS.
- this: call context required
- Event loop: how it works and where it bites required
- DOM events: bubbling, capturing, delegation required
- The browser and the network: where a page comes from, CORS, cookies and storage, XSS and CSRF required
- Critical Rendering Path required
- Error Handling in JavaScript and the Browser
- Animations: CSS and Optimizations
- Frontend Build: Bundlers and Approaches
- CSS Basics: Syntax, Linking Styles, and First Properties
- Cascade, specificity, and inheritance required
- Selectors: combinators, pseudo-classes, and pseudo-elements required
- The box model: sizes, box-sizing, and margin collapse required
- Document flow: display, visibility, and the float legacy required
- Positioning: from static to sticky and z-index required
- Flexbox: axes, alignment, and space distribution required
- Grid: two-dimensional layout required
- Units and responsiveness: rem, percentages, vw, and clamp required
- Styling: gradients, shadows, filters, and transforms
- Mock interview in the cabinet
-
Phase 35. React
Components, typing, the rendering model and hooks.
-
Phase 36. Frontend architecture
Project structure and architectural trade-offs: feature-based and layer-based design, FSD, module boundaries, Atomic Design and microfrontends.
-
Phase 37. Data and state
State, data fetching, errors, forms.
- State: Local and Server required
- MobX and Redux Toolkit: State Managers in React
- Data fetching in React: TanStack Query required
- Клиент из OpenAPI
- Frontend error handling: error boundaries, error states, and Suspense required
- Forms in React: react-hook-form and zod required
- Состояние в адресе
- Mock interview in the cabinet
-
Phase 38. Routing and delivery
Routing, styling and page delivery: SPA, SSR and SSG.
- Routing in React: React Router required
- Next.js и серверный рендер required
- Статические сайты и MDX
- Styling and design tokens required
-
Phase 39. Quality and performance
Accessibility, performance, testing.
-
Phase 40. Mobile app from the web
Web-first instead of native: PWA and Capacitor, native APIs through a bridge, iOS (WKWebView) and Android (TWA) specifics, push and offline — and the line where native starts.
-
Phase 41. What testing is
Why software is tested, the QA role, manual vs automated, the software and testing lifecycle.
- What Testing Is and Why It's Needed required
- Who a Tester Is and Their Role on the Team
- Testing Myths and What You Actually Need to Start
- Manual and Automated Testing: What's the Difference required
- The Software Lifecycle and Where Testing Fits (SDLC and STLC) required
- Software Development Models: Waterfall, V-Model, and Iterations
-
Phase 42. Types and levels
Test levels, functional and non-functional, black/white box, smoke and regression.
- Test Levels: Unit, Integration, System, and Acceptance required
- Types of Testing: Functional and Non-Functional required
- Non-Functional Testing Types in Practice required
- Black Box, White Box, and Grey Box; Smoke, Regression, and Sanity required
- Exploratory Testing and Degrees of Formalization required
- Localization Testing
-
Phase 43. Test-case design
Writing test cases, the test plan and suites, reporting and metrics, effort estimation, test-design techniques, decision tables, checklists and data.
- How to write a test case: steps and expected result required
- Test Case Quality: Balances, Fault-Finding Power, and Typical Mistakes
- Test plan and test suites: how to organize your checks required
- Test Result Reporting and Metrics required
- Effort Estimation in Testing
- Test design techniques: equivalence classes and boundary values required
- Decision tables and pairwise testing required
- Checklists and test data required
- User Scenarios, Personas, and Test Case Suites
-
Phase 44. Bugs
What a bug is, severity and priority, writing a bug report and making it high-quality, the bug lifecycle and trackers.
-
Phase 45. Tools and practice
Test management, web basics (HTML/CSS/JS), client-server and HTTP, DevTools, API in Postman, SQL, cross-browser testing and Linux commands.
- Test Management: TestRail, Qase, Zephyr
- Web Basics: HTML, CSS, JavaScript, and the DOM
- Client-Server and HTTP: How a Page Talks to a Server required
- Browser DevTools for Testers required
- API Testing Basics in Postman required
- API styles for testers: REST, SOAP and GraphQL required
- Networking basics: how a request finds the server required
- Logging in: authentication, authorization and tokens required
- SQL for Testers required
- Cross-Browser and Mobile Testing
- Mobile app testing
- Linux Commands and the Terminal for Testers
- Logs and monitoring for testers required
- Data formats for testers: JSON, XML, YAML and CSV required
- Microservices, brokers and queues through a tester's eyes required
-
Phase 46. Python for autotests
Python from scratch to autotests: variables and strings, conditions, lists and dicts, loops, functions, assert, working with data, pytest and API autotests. Every article comes with trainer tasks.
- Why a Tester Needs Python and How to Run the First Line
- Variables, Strings and Numbers required
- Comparisons and Conditions: How a Program Decides
- Lists and Dicts: JSON Is a Dict required
- Loops: Go Through Everything and Miss Nothing required
- Functions: Keep a Check in One Place required
- assert and Errors: How a Check Reports a Break
- Working with Data: Count, Compare, Find the Difference
- pytest: Your First Real Test required
- API Autotests in Python: Putting It Together required
- Mock interview in the cabinet
-
Phase 47. UI end-to-end tests
Playwright: when an end-to-end test is worth it, setup, test structure and page objects, resilient locators, waiting instead of sleeps, data and login without the form, network interception, flakiness and CI runs.
- Когда нужен e2e required
- Настройка
- Структура тестов required
- Локаторы required
- Утверждения и ожидание required
- Данные и аутентификация
- Сеть
- Нестабильные тесты required
- E2E в CI required
-
Phase 48. On a team and beyond
QA in Agile and Scrum, testing against requirements, automation basics and where to grow next.
- QA in Agile and Scrum: your role in a sprint required
- Testing against requirements required
- Requirement Levels and the Properties of Good Requirements
- Requirements Review: Techniques and Good Questions
- How Automation Works: Approaches and Economics required
- Git for testers: branches, commits and merges required
- CI/CD: The Pipeline, Tests and Artifacts
- Where to grow as a tester
-
Phase 49. The role and stepping into it
What changes after the promotion and how to step into a team.
- Из инженера в лида required
- Первые 90 дней тимлида required
-
Phase 50. The team: structure, ownership, people
System ownership, delegation, growing engineers, difficult conversations and leading several teams.
- Структура и владение required
- Делегирование и рост required
- Трудные разговоры required
- Почему уходят инженеры required
- Руководство направлением required
-
Phase 51. Hiring and onboarding
The profile before the search, evaluation stages and a new hire's first thirty days.
- Найм и ввод в работу required
-
Phase 52. Commitments: deadlines, flow, stakeholders
Estimates and commitments, inbound requests and choosing portfolio initiatives by money.
- Оценки и сроки required
- Стейкхолдеры и ожидания required
- Портфель и ROI required
-
Phase 53. Engineering norms and quality
Review norms, technical debt, requirements, security and regulation.
- Нормы код-ревью required
- Технический долг required
- Артефакты и требования required
- ИБ и регуляторика required
-
Phase 54. Reliability and operations
SLOs, alerts and observability of a running system.
-
Phase 55. Decisions and recording them
The architecture committee, decisions by criteria, technology through a manager's eyes and vendors.
- Архитектурный комитет required
- Architecture choice
- Технологии для менеджера required
- Вендоры и импортозамещение required
-
Phase 56. Measurement and the business conversation
Team metrics, the IT budget and technical risk in terms of money.
- Метрики команды required
- Бюджет ИТ: CAPEX и OPEX required
- Руководство и бизнес-риски required
Программа обучения v15.3.50
Product engineer · Python
The complete product engineer program on Python: FastAPI, backend, frontend and QA foundations, AI agents and LLM applications, then the full product cycle from problem to business metric and the management layer - team, hiring, commitments, quality, reliability, decisions and business communication.
The program has 2333 self-check questions in total.