-
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. JavaScript · 28 questions
Language and runtime foundations: values and references, scope, closures, prototypes, promises, async/await, the event loop and Node.js.
- 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
- How Node runs code: V8, libuv, event loop phases, the thread pool and garbage collection required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 3. TypeScript · 25 questions
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 test in the cabinet
-
Phase 4. 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 5. 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 6. Node.js runtime · 18 questions
How a Node process behaves under load: the event loop and libuv, files and streams, backpressure, workers, processes, timeouts and memory diagnostics.
- Event loop и libuv: как Node выполняет backend required
- Процесс и файловая система: env, файлы и закрытие ресурсов required
- Streams и backpressure: данные без лишней памяти required
- Worker threads: вычисления без блокировки event loop required
- Child process и cluster: процессы вместо общей памяти required
- Таймауты и отмена: AbortController и завершение операций required
- Event-loop lag: как измерить задержку основного потока required
- Память и утечки ресурсов: heap, listeners и соединения required
- Пулы ввода-вывода: UV_THREADPOOL_SIZE, сокеты и семафоры required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 7. Foundation: NestJS core · 24 questions
Modules and DI, controllers and routing, the request pipeline (pipes, guards, interceptors, filters), configuration and lifecycle, persistence with TypeORM, async and tasks.
- Модули и DI required hands-on code
- Контроллеры и роутинг required hands-on code
- Fastify production API required
- Валидация и pipes required hands-on code
- Guards и auth required hands-on code
- Interceptors required
- Exception filters required hands-on code
- Конфигурация и lifecycle required hands-on code
- TypeORM required hands-on code
- Async и очереди required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 8. 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 9. TypeORM and persistence · 22 questions
DataSource, entities, relations, QueryBuilder, transactions, locking, migrations, repositories and tests against real PostgreSQL.
- DataSource и EntityManager: соединение с PostgreSQL required
- Entities и типы колонок: numeric, bigint и даты required
- Relations и lazy loading: связи без N+1 required
- QueryBuilder: joins, параметры и проекции required
- Транзакции и isolation: сценарий целиком required
- Блокировки и версии: оптимизм и пессимизм required
- Миграции TypeORM: схема без synchronize required
- Репозиторий и Data Mapper: ORM за границей required
- Интеграционные тесты TypeORM на PostgreSQL required
- Производительность TypeORM: EXPLAIN, пагинация и ошибки required
- Prisma и Drizzle: persistence в Node.js required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 10. 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 11. 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 12. Other stores: documents, search, files, analytics · 206 questions
First the foundations — storage engines, replication, sharding, streams. Then the stores themselves: MongoDB, Elasticsearch, object storage (S3) and ClickHouse — choosing and operating them by workload profile.
- 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 TypeScript 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
- How Elasticsearch works in production: ILM, snapshots, sizing, monitoring
- Elasticsearch JS required
- What object storage is: bucket, object, key, storage classes and presigned URL hands-on code
- S3 in production: backups, replication, cost, and monitoring
- AWS SDK S3 required
- 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
- Operating Redis: persistence, memory, replication required
- Redis Node required
- How ClickHouse Works: Columnar Storage, MergeTree, and OLAP
- ClickHouse: schema modeling, queries, materialized views
- ClickHouse in production: replication, TTL, backups and monitoring
- ClickHouse JS required
- 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 13. Design principles and patterns · 36 questions
SOLID, GRASP, GoF patterns and the DRY/KISS/YAGNI principles with examples.
- SOLID: five principles of design in TypeScript required
- GoF Patterns: All 23 in Plain Words in TypeScript required
- GRASP: Assigning Responsibilities in TypeScript
- DRY, KISS, YAGNI and other engineering principles in TypeScript 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 14. 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 15. API: REST and contracts · 88 questions
URL naming and resources, query parameters, responses and errors, headers, versioning, OpenAPI and anti-patterns.
- URL and Resources in NestJS: How to Name Paths and Choose HTTP Methods required
- Query parameters in NestJS: filtering, pagination and search hands-on code
- JSON and Response Format in NestJS
- RFC 9457 Errors — Problem Details in NestJS required hands-on code
- HTTP Headers in NestJS: Standard, Custom, and Tracing required hands-on code
- REST API Versioning in NestJS — v1/v2 in the URL required
- Alias and Action Endpoints in NestJS — me, latest, default and Domain Commands
- OpenAPI in NestJS and common API design mistakes
- Rate Limiting, File Uploads, and Deprecation in NestJS
- Batch operations, long-running tasks, and localization in NestJS
- API-first required
- 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 16. Security and authorization · 127 questions
Where checks live, JWT validation, RBAC and ABAC, token storage, service-to-service, PII and auditing.
- Authentication and authorization patterns
- Where to Put the Auth Check in NestJS: Gateway, Controller and Handler required
- JWT Validation in NestJS: passport-jwt and jwks-rsa hands-on code
- RBAC in NestJS: Roles, Guards and JWT
- ABAC and Resource Ownership in NestJS hands-on code
- Storing Tokens in the Browser — HttpOnly Cookies and Refresh Rotation (NestJS)
- Service-to-Service Authentication in NestJS: mTLS and Client Credentials
- PII and Secrets in NestJS: How to Prevent Leaks required
- Audit Log of Admin Commands in NestJS 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
- 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 17. Brokers and distributed systems · 42 questions
AMQP/RabbitMQ and Kafka, 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 TypeScript
- NATS messaging: subjects, queue groups and JetStream explained
- NATS vs RabbitMQ vs Kafka: choosing a message broker
- Apache Kafka: topics, partitions, ordering and guarantees in TypeScript required hands-on code
- Kafka in production in TypeScript: kafkajs, DLQ, Schema Registry, tuning, security required hands-on code
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 18. Microservices: architecture and pitfalls · 33 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 TypeScript 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 TypeScript required hands-on code
- Resilience Patterns: Retry, Circuit Breaker, Bulkhead, DLQ in TypeScript required hands-on code
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 19. Containers: Docker · 60 questions
Containers and images, a Dockerfile for a Node service, multi-stage builds, running containers, volumes and data, networking, Docker Compose, the Node 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 для Node 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
- Node в контейнере required
- Small and Secure Docker Images
- Image Registries and Building in CI
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 20. Kubernetes and graceful shutdown · 62 questions
Cluster, networking, Kubernetes deployment and operations; graceful shutdown from HTTP draining to budgets and observability.
- 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
- How to configure graceful shutdown in NestJS: enableShutdownHooks and the drain state
- HTTP drain in NestJS: how not to lose requests on restart required
- How to close database connections when stopping a Node.js service
- Stopping background tasks in NestJS: scheduler, BullMQ, outbox hands-on code
- Kafka shutdown in NestJS: how to correctly stop the consumer and producer
- Idempotency of in-flight operations in NestJS hands-on code
- Graceful shutdown of NestJS in Kubernetes: preStop, probes, rolling deploy required
- Shutdown budgets and observability in NestJS
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 21. 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 22. CI/CD: the delivery pipeline · 32 questions
Pipeline principles, npm ci and TypeScript, Jest and Testcontainers, release strategies, branching and delivery.
- CI/CD principles: the pipeline from commit to production required
- CI для Node.js required
- pnpm и Turborepo required
- Release strategies: rolling, blue-green, canary, feature flags required
- Branching and the release cycle: trunk-based, versions, GitOps
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 23. Quality: test strategy · 29 questions
The test pyramid, integration tests with PostgreSQL, mocks and external services, load testing.
- Тестирование required hands-on code
- Интеграционные тесты required
- Моки и внешние системы required
- Load testing: k6, Gatling, JMeter
- The test pyramid: what goes where required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 24. Observability and diagnostics · 52 questions
How to see what a running system is doing: logs, metrics, tracing, context propagation, health checks, SLOs and alerts — plus Node profiling and the incident review afterwards.
- Наблюдаемость
- Structured logs in NestJS: pino, request context and personal data protection required
- Metrics in NestJS: prom-client, RED and USE methods required hands-on code
- Distributed tracing in NestJS: OpenTelemetry from scratch required
- Context propagation in NestJS: AsyncLocalStorage, middleware and queues
- Health checks in NestJS: liveness, readiness and /info hands-on code
- SLO and alerts in Node.js: error budget, burn rate and how not to miss an incident
- Observability in NestJS: management port, metrics and logs
- Профилирование и утечки 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 25. 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 26. Building LLM applications · 51 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 27. System design and architectural choices · 50 questions
The design method and building blocks, design docs, storage and synchronicity choices, ADR, the architect's role and C4 notation.
- 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 28. Domain-Driven Design · 43 questions
Strategic and tactical patterns, context integration and domain design principles.
- What DDD Is and Why You Need It required hands-on code
- Strategic DDD Patterns in TypeScript required
- DDD Tactical Patterns in TypeScript required hands-on code
- DDD Integration Patterns in TypeScript required
- Design Principles in DDD in TypeScript
- 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 29. Service architecture patterns · 58 questions
Service and microservice structure, Onion and Hexagonal, CQRS, resilience and batch processing.
- Onion Architecture required
- CQRS
- When to apply CQRS in NestJS required
- Command side in CQRS — how to write commands in NestJS required
- Query side in CQRS on NestJS — how reading data works
- Read-model in CQRS — a denormalized projection on NestJS / TypeScript
- Synchronizing the read-model via events in NestJS
- Tier and evolution of CQRS in NestJS
- Hexagonal architecture hands-on code
- When to Apply Hexagonal Architecture in Node/NestJS required
- The Core Layer in Hexagonal Architecture: Node/NestJS required hands-on code
- Ports in Hexagonal Architecture — Isolating the Core from the Outside World required
- Adapters In in Hexagonal Architecture with NestJS
- Out Adapters in Hexagonal with NestJS/TypeScript hands-on code
- Folder Structure in a Hexagonal Project with NestJS
- Bootstrap / Composition Root in Hexagonal (NestJS)
- Architecture Tests in a Hexagonal Project (NestJS) hands-on code
- Batch Data Processing: How Not to Break Your Background Worker in TypeScript
- Event Sourcing: Store Events, Not State
- Что это и когда нужны hands-on code
- BPM и Camunda
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 30. 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 31. 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 32. 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 33. The browser and practical CSS
Platform and styling: DOM, security, critical rendering, errors, animations, bundling and practical CSS.
- 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 34. React
Components, typing, the rendering model and hooks.
-
Phase 35. Frontend architecture
Project structure and architectural trade-offs: feature-based and layer-based design, FSD, module boundaries, Atomic Design and microfrontends.
-
Phase 36. 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 37. Routing and delivery
Routing, styling and page delivery: SPA, SSR and SSG.
- Routing in React: React Router required
- Next.js и серверный рендер required
- Next.js production required
- Статические сайты и MDX
- Styling and design tokens required
-
Phase 38. Quality and performance
Accessibility, performance, testing.
-
Phase 39. 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 40. 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 41. 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 42. 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 43. Bugs
What a bug is, severity and priority, writing a bug report and making it high-quality, the bug lifecycle and trackers.
-
Phase 44. 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 45. 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 46. 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 47. 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 48. The role and stepping into it
What changes after the promotion and how to step into a team.
- Из инженера в лида required
- Первые 90 дней тимлида required
-
Phase 49. The team: structure, ownership, people
System ownership, delegation, growing engineers, difficult conversations and leading several teams.
- Структура и владение required
- Делегирование и рост required
- Трудные разговоры required
- Почему уходят инженеры required
- Руководство направлением required
-
Phase 50. Hiring and onboarding
The profile before the search, evaluation stages and a new hire's first thirty days.
- Найм и ввод в работу required
-
Phase 51. Commitments: deadlines, flow, stakeholders
Estimates and commitments, inbound requests and choosing portfolio initiatives by money.
- Оценки и сроки required
- Стейкхолдеры и ожидания required
- Портфель и ROI required
-
Phase 52. Engineering norms and quality
Review norms, technical debt, requirements, security and regulation.
- Нормы код-ревью required
- Технический долг required
- Артефакты и требования required
- ИБ и регуляторика required
-
Phase 53. Reliability and operations
SLOs, alerts and observability of a running system.
-
Phase 54. Decisions and recording them
The architecture committee, decisions by criteria, technology through a manager's eyes and vendors.
- Архитектурный комитет required
- Architecture choice
- Технологии для менеджера required
- Вендоры и импортозамещение required
-
Phase 55. Measurement and the business conversation
Team metrics, the IT budget and technical risk in terms of money.
- Метрики команды required
- Бюджет ИТ: CAPEX и OPEX required
- Руководство и бизнес-риски required
Программа обучения v15.5.55
Product engineer · Node
The complete product engineer program on Node: NestJS and TypeScript, 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 2093 self-check questions in total.