vikulin-va.ru vikulin-va.ru
Courses Global remote jobs Contacts News
🇬🇧
vikulin-va.ru
Courses Become an engineer who ships the product Global remote jobs Land a remote role abroad — from CV to offer
Contacts News
→ Get in touch
Sign in Кабинет · cabinet Sign out

Reader profile

Specialization & language

The methodology contracts are language-neutral and always visible. Binding-specific sections are shown for the selected profile.

Specialization

Language

Backend · Node
  • Phase 1. Where to start ▾
    • Зачем этот курс
  • Phase 2. JavaScript ▾
    • Language basics: TypeScript ▾
      • JavaScript Essentials
      • Async and the Event Loop in TypeScript
    • JavaScript in Depth ▾
      • 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
      • How Node runs code: V8, libuv, event loop phases, the thread pool and garbage collection
    • Frontend ▾
      • this: call context
      • Event loop: how it works and where it bites
    • Node.js — первые шаги in the cabinet
    • JavaScript — переменные, функции, объекты in the cabinet
    • JavaScript — строки in the cabinet
    • JavaScript — массивы, объекты, Map и Set in the cabinet
    • JavaScript — функции, классы и асинхронность in the cabinet
    • Node.js для тех, кто пишет на Java in the cabinet
    • Phase test in the cabinet
  • Phase 3. TypeScript ▾
    • 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
    • Modules and npm: how code is assembled from parts
    • TypeScript and Node Tooling: Getting Started
    • Типы TypeScript с собеседований in the cabinet
    • Phase test in the cabinet
  • Phase 4. Algorithms and data structures ▾
    • Алгоритмы и структуры данных ▾
      • Why data structures and algorithms matter
      • Math behind big O: logarithms, powers and growth rates
      • Arrays and binary search: big-O notation, ArrayList and Arrays.binarySearch
      • 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
      • 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
      • 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
      • 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
    • Алгоритмы — приёмы решения in the cabinet
    • Алгоритмы с собеседований на JavaScript in the cabinet
    • Phase test in the cabinet
    • Low-latency: задержка как продукт ▾
      • Хвостовая латентность
      • Горячий путь
      • Order book
      • Маркет-дата
  • Phase 5. Git and branching models ▾
    • What Git is and why everyone needs it
    • Commits and history: add, commit, log, and .gitignore
    • Branches and merging: merge and conflicts
    • Remote repositories: push, pull, and fetch
    • Pull requests and code review
    • 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 ▾
    • Event loop и libuv: как Node выполняет backend
    • Процесс и файловая система: env, файлы и закрытие ресурсов
    • Streams и backpressure: данные без лишней памяти
    • Worker threads: вычисления без блокировки event loop
    • Child process и cluster: процессы вместо общей памяти
    • Таймауты и отмена: AbortController и завершение операций
    • Event-loop lag: как измерить задержку основного потока
    • Память и утечки ресурсов: heap, listeners и соединения
    • Пулы ввода-вывода: UV_THREADPOOL_SIZE, сокеты и семафоры
    • Node.js runtime — код-ревью in the cabinet
    • Phase test in the cabinet
  • Phase 7. Foundation: NestJS core ▾
    • Модули и DI
    • Контроллеры и роутинг
    • Валидация и pipes
    • Guards и auth
    • Interceptors
    • Exception filters
    • Конфигурация и lifecycle
    • TypeORM
    • Async и очереди
    • NestJS — код-ревью in the cabinet
    • NestJS — конфигурация и жизненный цикл in the cabinet
    • Асинхронный Node с собеседований in the cabinet
    • Phase test in the cabinet
  • Phase 8. SQL from scratch ▾
    • What a Database and Tables Are
    • SELECT: Pick, Filter, Sort
    • JOIN: Combine Data from Several Tables
    • Aggregates: COUNT, GROUP BY and HAVING
    • NULL and Data Types: Where Everyone Stumbles
    • Subqueries and CTEs: A Query Inside a Query
    • Window Functions: Counting Without Collapsing Rows
    • Даты и время
    • Строки
    • INSERT, UPDATE, DELETE and Transactions
    • Database Schema: Tables, Keys and Views
    • Why a Query Is Slow: Indexes on Your Fingers
    • Основы: SELECT, FROM, WHERE in the cabinet
    • Сортировка, LIMIT и DISTINCT in the cabinet
    • Соединения: JOIN и anti-join in the cabinet
    • Агрегаты, GROUP BY и HAVING in the cabinet
    • NULL и COALESCE in the cabinet
    • Подзапросы и CTE in the cabinet
    • Оконные функции in the cabinet
    • Даты и интервалы in the cabinet
    • Строки и типы in the cabinet
    • Phase test in the cabinet
  • Phase 9. TypeORM and persistence ▾
    • DataSource и EntityManager: соединение с PostgreSQL
    • Entities и типы колонок: numeric, bigint и даты
    • Relations и lazy loading: связи без N+1
    • QueryBuilder: joins, параметры и проекции
    • Транзакции и isolation: сценарий целиком
    • Блокировки и версии: оптимизм и пессимизм
    • Миграции TypeORM: схема без synchronize
    • Репозиторий и Data Mapper: ORM за границей
    • Интеграционные тесты TypeORM на PostgreSQL
    • Производительность TypeORM: EXPLAIN, пагинация и ошибки
    • TypeORM — код-ревью in the cabinet
    • Phase test in the cabinet
  • Phase 10. PostgreSQL: model and queries ▾
    • ACID and Transaction Isolation Levels in PostgreSQL
    • Transaction Isolation Levels in PostgreSQL
    • Locks in PostgreSQL: SELECT FOR UPDATE, SKIP LOCKED and advisory locks
    • 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
    • PostgreSQL Composite Indexes and the Leftmost Prefix Rule
    • Covering Index in PostgreSQL: why you need INCLUDE
    • How to Choose an Index and Estimate Selectivity in PostgreSQL
    • Weights in PostgreSQL full-text search
    • EXPLAIN ANALYZE — how to read a PostgreSQL query plan
    • PostgreSQL — планы запросов и индексы in the cabinet
    • Системный дизайн — поиск и рекомендации in the cabinet
    • PostgreSQL — jsonb, массивы и числа in the cabinet
    • Phase test in the cabinet
  • Phase 11. PostgreSQL: operations and scale ▾
    • PostgreSQL migrations with zero downtime
    • Connection pooling in PostgreSQL — HikariCP, PgBouncer and the Wooldridge formula
    • VACUUM, autovacuum and bloat in PostgreSQL
    • WAL in PostgreSQL: what it is and how to control the journal size
    • PostgreSQL replication: read-replica and query routing
    • PostgreSQL Backups: pg_dump, pg_basebackup and PITR
    • Partitioning in PostgreSQL: when you need it and how it works
    • 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
    • Системный дизайн — хранилища и кэш in the cabinet
    • PostgreSQL — поиск по тексту и по карте in the cabinet
    • Phase test in the cabinet
  • Phase 12. Other stores: documents, search, files, analytics ▾
    • Data foundations ▾
      • B-trees and LSM-trees in plain words: how a database stores data
      • OLTP and OLAP in plain words: two different worlds of working with data
      • Schema evolution in plain words: changing data formats without breaking anything
      • Replication models in plain words: why a replica lags, multi-leader, and quorums
      • Partitioning (sharding) in plain words: slicing data across nodes without a hot spot
      • 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
    • MongoDB ▾
      • ACID, read and write concerns, transactions in MongoDB in TypeScript
      • Replication and Sharding in MongoDB
      • Document modeling in MongoDB: embed vs reference, indexes
    • Elasticsearch ▾
      • Elasticsearch: how a search engine works
      • 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
    • Object storage (S3) ▾
      • What object storage is: bucket, object, key, storage classes and presigned URL
      • S3 in production: backups, replication, cost, and monitoring
      • AWS SDK S3
    • Redis ▾
      • What is Redis: an in-memory store for backend developers
      • Redis data structures: String, Hash, List, Set, Sorted Set and more
      • Caching Patterns in Redis
      • Redis Is Not Just for Caching: Locks, Rate Limiting, Queues and Pub/Sub
      • Operating Redis: persistence, memory, replication
      • Redis Node
    • ClickHouse ▾
      • How ClickHouse Works: Columnar Storage, MergeTree, and OLAP
      • ClickHouse: schema modeling, queries, materialized views
      • ClickHouse in production: replication, TTL, backups and monitoring
      • ClickHouse JS
    • Apache Cassandra ▾
      • Cassandra Architecture: a Ring With No Leader Node
      • Cassandra Data Model: Partition Key and Clustering Columns
      • Consistency and Replication in Cassandra: Tunable per Request
    • Neo4j ▾
      • 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
    • Architecture choice ▾
      • 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
    • MongoDB — запросы к документам in the cabinet
    • Neo4j — обход графа на Cypher in the cabinet
    • Redis — структуры и чтение in the cabinet
    • Node.js — интеграции хранилищ in the cabinet
    • Системный дизайн — гео и логистика in the cabinet
    • Phase test in the cabinet
  • Phase 13. Design principles and patterns ▾
    • SOLID: five principles of design in TypeScript
    • GoF Patterns: All 23 in Plain Words in TypeScript
    • GRASP: Assigning Responsibilities in TypeScript
    • DRY, KISS, YAGNI and other engineering principles in TypeScript
    • Clean Code: names, functions, comments
    • Low level design interview: solving design-in-code tasks
    • Код и тесты — задачи с собеседований in the cabinet
    • Phase test in the cabinet
  • Phase 14. Networking fundamentals ▾
    • How Networking Works: The OSI and TCP/IP Models
    • IP Addresses, Ports, and NAT
    • TCP and UDP: Reliability vs Speed
    • DNS: How a Domain Name Turns Into an Address
    • HTTP: Methods, Status Codes, Headers
    • HTTPS and TLS: Encryption and the Handshake
    • HTTP/1.1, HTTP/2, and HTTP/3: What Changed
    • Connections: Keep-Alive, Pools, and Timeouts
    • Два пула: БД и HTTP
    • Load Balancers and Reverse Proxies
    • Networking and Reliability: Timeouts, Retries, Idempotency
    • Диагностика сети
    • Linux for Backend Developers: Processes, Signals, Files and Memory
    • WebSocket, SSE and long polling
    • WebSocket: много подов
    • Сеть на Node.js — код-ревью in the cabinet
    • Системный дизайн — реальное время in the cabinet
    • Phase test in the cabinet
  • Phase 15. API: REST and contracts ▾
    • REST API ▾
      • 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
      • API-first
    • API Styles ▾
      • gRPC: Fast Calls Between Services
      • GraphQL: The Client Asks for Exactly What It Needs
      • HATEOAS: REST Maturity and Hyperlinks
    • Validation ▾
      • Where to Validate Data
    • Error handling ▾
      • Application error model
    • REST API на Node.js — код-ревью in the cabinet
    • Системный дизайн — деньги и надёжность in the cabinet
    • Phase test in the cabinet
  • Phase 16. Security and authorization ▾
    • Authentication and authorization patterns ▾
      • 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
    • Backend vulnerabilities ▾
      • Backend vulnerabilities
      • Инъекции
      • SSRF
      • IDOR и BOLA
      • Mass assignment и лишние поля
      • Обход пути и загрузки
      • XXE и десериализация
      • Подбор паролей и лимиты
      • Редирект, CSRF и CORS
      • Гонки и двойное списание
      • Ошибки с JWT
      • Как искать уязвимости
    • Keycloak ▾
      • What Keycloak Is and Why You Need It
      • OAuth2 and OIDC in plain words
      • Realm, client, roles and users in Keycloak
      • Authorization Code Flow and PKCE Step by Step
      • Three Keycloak tokens: access, id, refresh — which goes where
      • Kerberos and LDAP: Enterprise Authentication
    • Keycloak и безопасность на Node.js in the cabinet
    • Авторизация и данные на Node.js in the cabinet
    • Код-ревью: уязвимости in the cabinet
    • Phase test in the cabinet
  • Phase 17. Brokers and distributed systems ▾
    • AMQP ▾
      • The AMQP protocol: exchange, queue, binding, ack
      • 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 ▾
      • Apache Kafka: topics, partitions, ordering and guarantees in TypeScript
      • Kafka in production in TypeScript: kafkajs, DLQ, Schema Registry, tuning, security
    • Системный дизайн — очереди и события in the cabinet
    • Phase test in the cabinet
  • Phase 18. Microservices: architecture and pitfalls ▾
    • Architecture choice ▾
      • Choosing your starting architecture: monolith, modular monolith, microservices
      • Between services: synchronous call or events
    • Architecture patterns ▾
      • Structural Patterns for Microservices in TypeScript
      • Distributed patterns: data consistency across services in TypeScript
      • Resilience Patterns: Retry, Circuit Breaker, Bulkhead, DLQ in TypeScript
    • Distributed systems ▾
      • The trouble with distributed systems in plain words: partial failures, unreliable clocks, truth by quorum
      • Consistency and consensus in plain words: linearizability, CAP, and one shared problem
      • Correctness in a distributed system in plain words: the end-to-end argument, exactly-once, integrity versus timeliness
    • Node.js - распределенные системы: код-ревью in the cabinet
    • Системный дизайн — основы: нагрузка и контракт in the cabinet
    • Phase test in the cabinet
  • Phase 19. Containers: Docker ▾
    • What Docker and Containers Are
    • Images, layers and the Dockerfile: how Docker packages an application
    • Dockerfile для Node
    • Docker Multi-Stage Builds and Layer Caching
    • 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
    • Node в контейнере
    • Small and Secure Docker Images
    • Image Registries and Building in CI
    • Docker для Node.js - код-ревью in the cabinet
    • Phase test in the cabinet
  • Phase 20. Kubernetes and graceful shutdown ▾
    • Kubernetes ▾
      • Kubernetes: pod, deployment, service — where to start
      • Networking in Kubernetes: Service, DNS, Ingress, NetworkPolicy
      • Deploying to Kubernetes: manifests, Helm, rolling update, GitOps
      • Kubernetes in practice: debugging pods and kubectl commands
      • OpenShift: How It Differs from Vanilla Kubernetes
      • Helm
      • Argo CD
    • Graceful Shutdown ▾
      • 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
    • Kubernetes и остановка NestJS - код-ревью in the cabinet
    • Phase test in the cabinet
  • Phase 21. Clouds ▾
    • Облака: общие принципы ▾
      • Что такое облако
      • Регионы и зоны
      • Учётные записи и права
      • Сеть
      • Вычисления
      • Управляемые данные
      • Наблюдаемость и секреты
      • Деньги
      • Отказоустойчивость
    • AWS ▾
      • 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
    • Microsoft Azure ▾
      • Основы
      • Сеть
      • Entra ID и RBAC
      • Где запускать сервис
      • Масштабирование и доступность
      • Serverless
      • Управляемые данные
      • Cosmos DB
      • Blob Storage
      • Из приложения
      • Безопасность и наблюдаемость
      • Оптимизация затрат
      • Отказоустойчивость и DR
      • Инфраструктура как код
    • Google Cloud Platform (GCP) ▾
      • Основы
      • Сеть
      • Cloud IAM
      • Где запускать сервис
      • Масштабирование и доступность
      • Serverless
      • Управляемые данные
      • Firestore и NoSQL
      • Cloud Storage
      • Из приложения
      • Безопасность и наблюдаемость
      • Оптимизация затрат
      • Отказоустойчивость и DR
      • Terraform
    • Системный дизайн — медиа и файлы in the cabinet
    • Phase test in the cabinet
  • Phase 22. CI/CD: the delivery pipeline ▾
    • CI/CD principles: the pipeline from commit to production
    • CI для Node.js
    • Release strategies: rolling, blue-green, canary, feature flags
    • Branching and the release cycle: trunk-based, versions, GitOps
    • CI для Node.js - код-ревью in the cabinet
    • Phase test in the cabinet
  • Phase 23. Quality: test strategy ▾
    • NestJS ▾
      • Тестирование
    • Testing ▾
      • Интеграционные тесты
      • Моки и внешние системы
      • Load testing: k6, Gatling, JMeter
      • The test pyramid: what goes where
    • Тестирование Node.js и NestJS - код-ревью in the cabinet
    • Phase test in the cabinet
  • Phase 24. Observability and diagnostics ▾
    • NestJS ▾
      • Наблюдаемость
    • Observability ▾
      • 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
      • Профилирование и утечки
      • От алерта до строки лога
    • Team management ▾
      • Постмортем и дежурства
    • PostgreSQL ▾
      • PostgreSQL monitoring: slow queries, activity, and key metrics
      • Отчёт нагрузки (pg_profile)
      • Запросы для отчёта нагрузки
    • Наблюдаемость на Node.js - код-ревью in the cabinet
    • Системный дизайн — эксплуатация in the cabinet
    • Инциденты — разбор аварий in the cabinet
    • Phase test in the cabinet
  • Phase 25. Working with AI agents ▾
    • How AI Models Work: Predicting the Next Token
    • AI Hallucinations: Why the Model Confidently Makes Things Up
    • Tokens and Cost: What You Pay For When Working With AI
    • Context: What the Model Holds in Mind at Once
    • Tool Calling: How the Model Reaches Beyond Text
    • Agents: A Model in a Loop with Tools and a Goal
    • Working with Agents: The Basic Loop of a Productive Session
    • Команды 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 ▾
    • What an LLM feature is made of
    • LangChain: orchestrating LLM applications
    • RAG and embeddings: giving the model your data
    • Vector databases
    • Agent applications: tools and autonomous loops
    • 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 ▾
    • System design ▾
      • Reliability, scalability, maintainability — in plain words
      • The system design method: from requirements to architecture
      • Building Blocks of System Design
      • How a Notification System Works: Architecture From Scratch
      • How to write and defend a system design: design doc, C4, review
    • Architecture choice ▾
      • ADR: how to record architecture decisions
      • The Architect's Role in a Development Team
    • C4 model ▾
      • C4 model
    • Системный дизайн — основы: нагрузка и контракт in the cabinet
    • Системный дизайн — хранилища и кэш in the cabinet
    • Системный дизайн — очереди и события in the cabinet
    • Системный дизайн — поиск и рекомендации in the cabinet
    • Системный дизайн — медиа и файлы in the cabinet
    • Системный дизайн — реальное время in the cabinet
    • Системный дизайн — деньги и надёжность in the cabinet
    • Системный дизайн — эксплуатация in the cabinet
    • Системный дизайн — гео и логистика in the cabinet
    • Системный дизайн — практика in the cabinet
    • Phase test in the cabinet
  • Phase 28. Domain-Driven Design ▾
    • What DDD Is and Why You Need It
    • 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 29. Service architecture patterns ▾
    • Architecture patterns ▾
      • Onion Architecture
      • Batch Data Processing: How Not to Break Your Background Worker in TypeScript
      • Event Sourcing: Store Events, Not State
    • CQRS ▾
      • 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 ▾
      • 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)
    • Конечные автоматы и стейт-машины ▾
      • Что это и когда нужны
      • BPM и Camunda
    • Слои и границы на Node.js - код-ревью in the cabinet
    • CQRS и события на Node.js - код-ревью in the cabinet
    • Phase test in the cabinet
  • Phase 30. Development methodologies and process ▾
    • Методологии и процесс разработки ▾
      • Development Models: From Waterfall to Agile
      • Scrum: Roles, Events, and Artifacts
      • Kanban: Flow, WIP Limits, and Pull
      • Extreme Programming: the Engineering Practices of Agile
      • Estimation and planning: story points and velocity
      • Scaling Agile: SAFe and LeSS
    • Product engineer ▾
      • A Methodology for AI: Use Case Pattern and Other Ways
    • Phase test in the cabinet
  • Phase 31. The product engineer: role and practice ▾
    • 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
    • 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 ▾
    • 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
    • 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 ▾
    • Frontend ▾
      • DOM events: bubbling, capturing, delegation
      • The browser and the network: where a page comes from, CORS, cookies and storage, XSS and CSRF
      • Critical Rendering Path
      • Error Handling in JavaScript and the Browser
      • Animations: CSS and Optimizations
      • Frontend Build: Bundlers and Approaches
    • Браузер руками с собеседований in the cabinet
    • Phase test in the cabinet
    • CSS in Depth ▾
      • CSS Basics: Syntax, Linking Styles, and First Properties
      • Cascade, specificity, and inheritance
      • Selectors: combinators, pseudo-classes, and pseudo-elements
      • The box model: sizes, box-sizing, and margin collapse
      • Document flow: display, visibility, and the float legacy
      • Positioning: from static to sticky and z-index
      • Flexbox: axes, alignment, and space distribution
      • Grid: two-dimensional layout
      • Units and responsiveness: rem, percentages, vw, and clamp
      • Styling: gradients, shadows, filters, and transforms
    • Phase test in the cabinet
  • Phase 34. React ▾
    • React Components: Structure and Composition
    • TypeScript in React
    • How React draws: Virtual DOM, reconciliation, Fiber and re-renders
    • React Hooks: Rules, Custom Hooks, and useEffect
    • Ревью React-компонентов с собеседований in the cabinet
    • Лайвкодинг React с собеседований in the cabinet
    • Phase test in the cabinet
  • Phase 35. Frontend architecture ▾
    • React+TypeScript Project Structure
    • Архитектурные подходы
    • Feature-Sliced Design
    • Границы и линтер
    • Micro-frontends and Module Federation
    • Phase test in the cabinet
  • Phase 36. Data and state ▾
    • State: Local and Server
    • MobX and Redux Toolkit: State Managers in React
    • Data fetching in React: TanStack Query
    • Клиент из OpenAPI
    • Frontend error handling: error boundaries, error states, and Suspense
    • Forms in React: react-hook-form and zod
    • Состояние в адресе
    • Данные в React-компонентах с собеседований in the cabinet
    • Phase test in the cabinet
  • Phase 37. Routing and delivery ▾
    • Routing in React: React Router
    • Next.js и серверный рендер
    • Статические сайты и MDX
    • Styling and design tokens
    • Phase test in the cabinet
  • Phase 38. Quality and performance ▾
    • Accessibility (a11y)
    • Rendering performance
    • Frontend testing: Vitest and Testing Library
    • Окружение и секреты
    • Ревью экранов с собеседований in the cabinet
    • Phase test in the cabinet
  • Phase 39. Mobile app from the web ▾
    • Web-first или натив
    • PWA
    • Capacitor
    • Нативные API и плагины
    • iOS и WKWebView
    • Android TWA
    • Push-уведомления
    • Офлайн и хранение
    • Предел web-first
    • Phase test in the cabinet
  • Phase 40. What testing is ▾
    • What Testing Is and Why It's Needed
    • 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
    • The Software Lifecycle and Where Testing Fits (SDLC and STLC)
    • Software Development Models: Waterfall, V-Model, and Iterations
    • Phase test in the cabinet
  • Phase 41. Types and levels ▾
    • Test Levels: Unit, Integration, System, and Acceptance
    • Types of Testing: Functional and Non-Functional
    • Non-Functional Testing Types in Practice
    • Black Box, White Box, and Grey Box; Smoke, Regression, and Sanity
    • Exploratory Testing and Degrees of Formalization
    • Localization Testing
    • Phase test in the cabinet
  • Phase 42. Test-case design ▾
    • How to write a test case: steps and expected result
    • Test Case Quality: Balances, Fault-Finding Power, and Typical Mistakes
    • Test plan and test suites: how to organize your checks
    • Test Result Reporting and Metrics
    • Effort Estimation in Testing
    • Test design techniques: equivalence classes and boundary values
    • Decision tables and pairwise testing
    • Checklists and test data
    • User Scenarios, Personas, and Test Case Suites
    • Phase test in the cabinet
  • Phase 43. Bugs ▾
    • What is a bug: severity and priority
    • How to write a bug report
    • Bug Report Quality: Logic, Properties, and Typical Mistakes
    • Finding the Root Cause of a Defect
    • Bug lifecycle and trackers (Jira)
    • Phase test in the cabinet
  • Phase 44. Tools and practice ▾
    • Test Management: TestRail, Qase, Zephyr
    • Web Basics: HTML, CSS, JavaScript, and the DOM
    • Client-Server and HTTP: How a Page Talks to a Server
    • Browser DevTools for Testers
    • API Testing Basics in Postman
    • API styles for testers: REST, SOAP and GraphQL
    • Networking basics: how a request finds the server
    • Logging in: authentication, authorization and tokens
    • SQL for Testers
    • Cross-Browser and Mobile Testing
    • Mobile app testing
    • Linux Commands and the Terminal for Testers
    • Logs and monitoring for testers
    • Data formats for testers: JSON, XML, YAML and CSV
    • Microservices, brokers and queues through a tester's eyes
    • Phase test in the cabinet
  • Phase 45. Python for autotests ▾
    • Python для тестировщика ▾
      • Why a Tester Needs Python and How to Run the First Line
      • Variables, Strings and Numbers
      • Comparisons and Conditions: How a Program Decides
    • Python для тестировщика — первые шаги in the cabinet
    • Python для тестировщика ▾
      • Lists and Dicts: JSON Is a Dict
      • Loops: Go Through Everything and Miss Nothing
    • Python для тестировщика — списки и словари in the cabinet
    • Python для тестировщика ▾
      • Functions: Keep a Check in One Place
      • assert and Errors: How a Check Reports a Break
    • Python для тестировщика — функции и assert in the cabinet
    • Python для тестировщика ▾
      • Working with Data: Count, Compare, Find the Difference
    • Python для тестировщика — проверки данных in the cabinet
    • Python для тестировщика ▾
      • pytest: Your First Real Test
      • API Autotests in Python: Putting It Together
    • Автотесты API на Python in the cabinet
    • API с собеседований тестировщика in the cabinet
    • Лайвкодинг с собеседований тестировщика in the cabinet
    • Phase test in the cabinet
  • Phase 46. UI end-to-end tests ▾
    • Когда нужен e2e
    • Настройка
    • Структура тестов
    • Локаторы
    • Утверждения и ожидание
    • Данные и аутентификация
    • Сеть
    • Нестабильные тесты
    • E2E в CI
    • Phase test in the cabinet
  • Phase 47. On a team and beyond ▾
    • QA in Agile and Scrum: your role in a sprint
    • Testing against requirements
    • Requirement Levels and the Properties of Good Requirements
    • Requirements Review: Techniques and Good Questions
    • How Automation Works: Approaches and Economics
    • Git for testers: branches, commits and merges
    • CI/CD: The Pipeline, Tests and Artifacts
    • Where to grow as a tester
    • Phase test in the cabinet
Главная › TypeORM

TypeORM

TypeORM в NestJS: DataSource, entities, relations, QueryBuilder, транзакции, блокировки, миграции, репозитории и тесты PostgreSQL.

Раздел о работе с PostgreSQL через TypeORM: от DataSource и сущностей до транзакций, миграций и производительности.

Статьи раздела
  • DataSource и EntityManager: соединение с PostgreSQL
  • Entities и типы колонок: numeric, bigint и даты
  • Relations и lazy loading: связи без N+1
  • QueryBuilder: joins, параметры и проекции
  • Транзакции и isolation: сценарий целиком
  • Блокировки и версии: оптимизм и пессимизм
  • Миграции TypeORM: схема без synchronize
  • Репозиторий и Data Mapper: ORM за границей
  • Интеграционные тесты TypeORM на PostgreSQL
  • Производительность TypeORM: EXPLAIN, пагинация и ошибки

Learn by a program.

Six programs across specializations: phases, articles, trainers, and pass-mark tests. Pick your track and learn with a mentor.

Pick a program → Enroll →

Three free days of full access: trainers, pass-mark tests and the AI mentor. No payment, no card.

Sign in with Yandex →

What's new Standards End-to-end case Libraries Methodology (Use Case Pattern)

Offer Personal data policy Consent to data processing Cookie policy Recommendation technologies Cookie settings

This information resource uses recommendation technologies.

© 2026 vikulin-va.ru Contacts Telegram RSS LinkedIn GitHub

The site counts visits with Yandex Metrica, which sets a cookie in your browser and records what you do on the page. The counter does not load without your consent, and declining hides nothing. What is collected and why is set out in the cookie policy.