-
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: JavaScript and TypeScript · 18 questions
Essential JavaScript, async and the event loop, modules and npm, types, generics, type narrowing, classes and decorators, tooling — language foundations.
- JavaScript Essentials
- TypeScript Basic Types: Annotations, Inference, Union and Any
- Type Narrowing and Guards in TypeScript
- Generics in TypeScript: Reusable Type-Safe Code
- Classes and Decorators in TypeScript
- Async and the Event Loop in TypeScript
- 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 3. JavaScript in depth · 18 questions
The language core under the runtime: types and coercion, scope and closures, prototypes, references and copying, promises from the inside, iterators and generators — what server-side code trips over once TypeScript has compiled away.
- Types in JavaScript: primitives, objects, and typeof
- Type coercion: ==, === and truthy/falsy
- Scope: var, let, const and hoisting
- Closures: how they work and why you need them
- Prototypes: delegation and classes as sugar
- Objects: references, copying, and immutability
- Promises from the inside: chains, errors, and async/await
- Iterators and generators
- Phase test in the cabinet
-
Phase 4. Algorithms and data structures · 44 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 5. Git and branching models · 27 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 6. Foundation: NestJS core · 19 questions
Modules and DI, controllers and routing, the request pipeline (pipes, guards, interceptors, filters), configuration and lifecycle, persistence with TypeORM, async and tasks.
-
Phase 7. SQL from scratch · 46 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 8. Data: PostgreSQL · 19 questions
Relational fundamentals — ACID and isolation levels, partitioning and sharding.
-
Phase 9. Other stores: documents, search, files, analytics · 135 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
- 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 10. Design principles and patterns · 28 questions
SOLID, GRASP, GoF patterns and the DRY/KISS/YAGNI principles with examples.
-
Phase 11. 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 12. API: REST and contracts · 49 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
- Query parameters in NestJS: filtering, pagination and search
- JSON and Response Format in NestJS
- RFC 9457 Errors — Problem Details in NestJS
- HTTP Headers in NestJS: Standard, Custom, and Tracing
- REST API Versioning in NestJS — v1/v2 in the URL
- 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
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 13. Security and authorization · 24 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
- JWT Validation in NestJS: passport-jwt and jwks-rsa
- RBAC in NestJS: Roles, Guards and JWT
- ABAC and Resource Ownership in NestJS
- 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
- Audit Log of Admin Commands in NestJS
- PCI DSS for developers
- GDPR for Developers
- Phase test in the cabinet
-
Phase 14. Brokers and distributed systems · 37 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
- AMQP vs Kafka: which broker to choose required
- Apache Kafka: topics, partitions, ordering and guarantees in TypeScript
- Kafka in production in TypeScript: kafkajs, DLQ, Schema Registry, tuning, security
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 15. 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 TypeScript
- 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 TypeScript
- Resilience Patterns: Retry, Circuit Breaker, Bulkhead, DLQ in TypeScript
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 16. Kubernetes and graceful shutdown · 34 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
- 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
- How to close database connections when stopping a Node.js service
- Stopping background tasks in NestJS: scheduler, BullMQ, outbox
- Kafka shutdown in NestJS: how to correctly stop the consumer and producer
- Idempotency of in-flight operations in NestJS
- Graceful shutdown of NestJS in Kubernetes: preStop, probes, rolling deploy
- Shutdown budgets and observability in NestJS
- Phase test in the cabinet
-
Phase 17. Clouds · 87 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 18. CI/CD: the delivery pipeline · 19 questions
Pipeline principles, release strategies, branching and delivery.
-
Phase 19. Quality: test strategy · 8 questions
The test pyramid, slices and integration tests, mocks and external services, load testing.
-
Phase 20. Observability and diagnostics · 31 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.
- Наблюдаемость
- Structured logs in NestJS: pino, request context and personal data protection
- Metrics in NestJS: prom-client, RED and USE methods
- Distributed tracing in NestJS: OpenTelemetry from scratch
- Context propagation in NestJS: AsyncLocalStorage, middleware and queues
- Health checks in NestJS: liveness, readiness and /info
- 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
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 21. Working with AI agents · 39 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 22. 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 23. System design and architectural choices · 32 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 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 24. Domain-Driven Design · 19 questions
Strategic and tactical patterns, context integration and domain design principles.
- What DDD Is and Why You Need It required
- Strategic DDD Patterns in TypeScript
- DDD Tactical Patterns in TypeScript
- DDD Integration Patterns in TypeScript
- 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 25. Service architecture patterns · 36 questions
Service and microservice structure, Onion and Hexagonal, CQRS, resilience and batch processing.
- Onion Architecture required
- CQRS
- When to apply CQRS in NestJS
- Command side in CQRS — how to write commands in NestJS
- 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
- When to Apply Hexagonal Architecture in Node/NestJS
- The Core Layer in Hexagonal Architecture: Node/NestJS
- Ports in Hexagonal Architecture — Isolating the Core from the Outside World
- Adapters In in Hexagonal Architecture with NestJS
- Out Adapters in Hexagonal with NestJS/TypeScript
- Folder Structure in a Hexagonal Project with NestJS
- Bootstrap / Composition Root in Hexagonal (NestJS)
- Architecture Tests in a Hexagonal Project (NestJS)
- Batch Data Processing: How Not to Break Your Background Worker in TypeScript
- Event Sourcing: Store Events, Not State
- Phase test in the cabinet
-
Phase 26. Development methodologies and process · 19 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
Программа обучения v12.1.69
Backend · Node
A backend engineer training program on Node (NestJS + TypeScript). Sixteen phases from NestJS fundamentals through data, design principles and patterns, search, infrastructure, and quality to system design and DDD, culminating in the Use Case Pattern, and finally an end-to-end marketplace case study. The conceptual phases are shared across languages; the tooling ones use the Node stack.
The program has 880 self-check questions in total.