-
Phase 1. Where to start
Why this course exists and who it fits: the problem it solves, how phases, tests and trainers work, and how to go through it without dropping off.
- Зачем этот курс required
-
Phase 2. Language basics: Java · 70 questions
Syntax and types, OOP, collections, generics, exceptions, lambdas and Stream API, modern Java, tooling — language foundations before frameworks.
- Java Syntax and Types: Where the Code Begins required
- OOP in Java: classes, inheritance, interfaces, record and enum required
- Java Collections: Lists, Sets and Maps required
- How HashMap Works Inside
- Generics in Java: type safety without casting required
- Exceptions in Java: hierarchy, checked/unchecked, try-with-resources required
- Lambdas and the Stream API in Java required
- Records, Optional, and modern Java
- Загрузка классов
- Garbage Collection in Java
- Java Tooling: JDK, javac, jar, Maven and Gradle
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 3. Algorithms and data structures · 52 questions
Arrays and Big-O, sorting, stacks and queues, lists, recursion, trees, hash tables, heaps and graphs — the foundation under collections, indexes and stores.
- Why data structures and algorithms matter
- Math behind big O: logarithms, powers and growth rates required
- Arrays and binary search: big-O notation, ArrayList and Arrays.binarySearch required
- Simple sorting: bubble, selection, insertion required
- Stacks and queues: LIFO, FIFO, circular queue and ArrayDeque
- Linked Lists: Nodes, References and Why LinkedList Loses to ArrayList
- Recursion: base case, call stack and divide and conquer required
- Advanced sorting: Shell sort, quicksort and radix sort
- Binary search trees: the rule, traversal, deletion and TreeMap
- Red-black trees: rotations, recoloring and TreeMap
- 2-3-4 trees and B-trees: multi-key nodes and database indexes
- Hash tables: hash function, collisions and load factor required
- Heaps: weak ordering, sift up and sift down, PriorityQueue
- Graphs: vertices, edges, DFS and BFS
- Weighted graphs: minimum spanning tree and shortest path
- Two pointers and the sliding window required
- Prefix sums: a range sum as the difference of two numbers required
- Binary search on the answer: monotonicity, bounds and the loop invariant required
- Monotonic stack: next greater element in a single pass required
- Dynamic programming: overlapping subproblems, memoisation and tables required
- Backtracking: the search tree, undoing state, pruning dead branches required
- Choosing a data structure: array, list, tree or hash table required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 4. Git and branching models · 24 questions
Snapshots and commits, branches and merging, push/pull, pull requests and code review, rebase and reflog, branching models from Git Flow to trunk-based.
- What Git is and why everyone needs it required
- Commits and history: add, commit, log, and .gitignore required
- Branches and merging: merge and conflicts required
- Remote repositories: push, pull, and fetch required
- Pull requests and code review required
- Rebase and cherry-pick: rewriting history
- Undo and recovery: reset, revert, reflog
- Branching models: Git Flow, GitHub Flow, trunk-based
- Phase test in the cabinet
-
Phase 5. Foundation: Spring core · 37 questions
DI/IoC, bean lifecycle, Boot, MVC, Data JPA, transactions, events, AOP, scheduler.
- Spring DI/IoC, bean lifecycle, and scopes required
- Spring Bean Lifecycle with Examples required
- Spring Boot auto-configuration, properties, profiles required
- Spring MVC: Controllers, REST, Validation and Error Handling required
- @Transactional in Spring: transactions, propagation, pitfalls required
- Spring Data JPA: repositories, query methods, projections, N+1 required
- Spring Events: @EventListener, @TransactionalEventListener, asynchronous events
- Spring AOP: aspects, proxies and why @Transactional sometimes stays silent
- Spring WebFlux: when to use it, Mono/Flux, R2DBC
- Spring Scheduled, Async, virtual threads
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 6. Multithreading and concurrency · 36 questions
Threads and the Java memory model (JMM, happens-before, volatile), race conditions, synchronized and explicit locks, atomics and CAS, thread-safe collections, thread pools, CompletableFuture, Java 21 virtual threads, and common bugs — deadlock, livelock, starvation.
- Threads and Processes in Java required
- Java Memory Model (JMM): Visibility and happens-before required
- Races in multithreaded programs: race condition and data race required
- synchronized and monitors: mutual exclusion in Java required
- Explicit Locks: Lock and ReentrantLock required
- Atomic Variables and CAS in Java
- Thread-Safe Collections in Java
- Thread Pools: ExecutorService required
- CompletableFuture: Asynchronous Tasks in Java
- Virtual Threads in Java 21
- Structured Concurrency: StructuredTaskScope
- Deadlock, livelock, and starvation: when threads get in each other's way required
- Concurrency in practice: Spring required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 7. Design principles and patterns · 26 questions
SOLID, GRASP, GoF patterns, DRY/KISS/YAGNI.
-
Phase 8. SQL from scratch · 40 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 9. PostgreSQL: model and queries · 63 questions
Transactions and isolation, locking, data types, indexes and EXPLAIN.
- ACID and Transaction Isolation Levels in PostgreSQL required
- Transaction Isolation Levels in PostgreSQL required
- Spring @Transactional: how transactions work and where they break required
- Locks in PostgreSQL: SELECT FOR UPDATE, SKIP LOCKED and advisory locks required
- 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 required
- Arrays and range types in PostgreSQL: tags, bookings, EXCLUDE
- PostgreSQL Index Types — B-tree, GIN, GiST, BRIN required
- PostgreSQL Composite Indexes and the Leftmost Prefix Rule required
- Covering Index in PostgreSQL: why you need INCLUDE
- 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 10. PostgreSQL: operations and scale · 69 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 required
- 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 required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 11. Hibernate and ORM · 33 questions
Object-relational mapping: mapping entities and associations, persistence context, lazy loading and N+1, JPQL and Criteria, caching, transactions and locking, inheritance and common pitfalls.
- What ORM and Hibernate Are: From JDBC to Object-Relational Mapping required
- Entity Mapping in Hibernate and JPA required
- Entity Associations in Hibernate: @OneToMany, @ManyToOne, @ManyToMany required
- Persistence context and entity states in Hibernate required
- Lazy and Eager Loading in Hibernate required
- The N+1 Query Problem in Hibernate required
- JPQL, Criteria API, and Native Queries in Hibernate
- Caching in Hibernate: first-level, second-level and query cache
- Transactions, flush, and locking in Hibernate required
- Entity Inheritance in Hibernate: SINGLE_TABLE, JOINED, TABLE_PER_CLASS
- Common Hibernate mistakes: what goes wrong and how to fix it
- Phase test in the cabinet
-
Phase 12. Other stores: documents, search, files, analytics · 156 questions
First the foundations — storage engines, replication, sharding, streams. Then the stores themselves: MongoDB, Elasticsearch, object storage (S3) and ClickHouse.
- B-trees and LSM-trees in plain words: how a database stores data required
- OLTP and OLAP in plain words: two different worlds of working with data required
- Schema evolution in plain words: changing data formats without breaking anything
- Replication models in plain words: why a replica lags, multi-leader, and quorums required
- Partitioning (sharding) in plain words: slicing data across nodes without a hot spot required
- System of record and derived data in plain words: why a cache, an index, and a read model are the same thing
- Stream processing in plain words: change data capture (CDC) and time in streams
- ACID, read and write concerns, transactions in MongoDB required
- Document modeling in MongoDB: embed vs reference, indexes required
- Replication and Sharding in MongoDB
- Elasticsearch: how a search engine works required
- How Queries Work in Elasticsearch and Why Documents Are Ranked the Way They Are required
- Spring Data Elasticsearch: how to connect and use search in a Java application
- How Elasticsearch works in production: ILM, snapshots, sizing, monitoring
- What object storage is: bucket, object, key, storage classes and presigned URL required
- Spring + AWS SDK v2 for S3: integration, patterns, MinIO
- S3 in production: backups, replication, cost, and monitoring
- What is Redis: an in-memory store for backend developers required
- Redis data structures: String, Hash, List, Set, Sorted Set and more required
- Caching Patterns in Redis required
- Redis Is Not Just for Caching: Locks, Rate Limiting, Queues and Pub/Sub
- Redis in Spring Boot: RedisTemplate, @Cacheable and Spring Session
- Operating Redis: persistence, memory, replication
- How ClickHouse Works: Columnar Storage, MergeTree, and OLAP required
- ClickHouse: schema modeling, queries, materialized views required
- ClickHouse from Java and Spring Boot: connecting, writing, and reading
- 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 13. Networking fundamentals · 40 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 14. API: REST and contracts · 94 questions
URLs and resources, query parameters, responses and errors, versioning, OpenAPI.
- REST URLs and resources: how to name paths and pick HTTP methods required
- Query Parameters and Pagination in a REST API required
- JSON and Response Format in REST API required
- Errors in REST API — the Problem Details format required
- HTTP Headers in REST API: Content-Type, Authorization, Idempotency-Key, and Tracing required
- REST API versioning — how to change an API without breaking clients required
- Alias segments and action endpoints in REST API
- API-first and contract-first: design the contract before the code required
- OpenAPI: metadata and common mistakes in REST
- Rate limiting, file upload and deprecation in REST API
- Batch operations, async, and localization in REST API
- 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
- Bean Validation in Spring: @NotNull, @Valid and MethodArgumentNotValidException required
- Custom Constraints and Error Messages
- Application error model required
- A single error handler required
- Common Pitfalls in Exception Handling
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 15. Security and authorization · 49 questions
Spring Security, Keycloak/OAuth2/OIDC and authorization patterns.
- Spring Security: filters, AuthN, AuthZ, OAuth2 required
- What Keycloak Is and Why You Need It required
- OAuth2 and OIDC in plain words required
- Realm, client, roles and users in Keycloak required
- Authorization Code Flow and PKCE Step by Step required
- Keycloak and Spring Security: validating tokens required
- Roles and Access: RBAC and ABAC with Keycloak
- Three Keycloak tokens: access, id, refresh — which goes where
- Kerberos and LDAP: Enterprise Authentication
- Authentication and authorization patterns
- Where Each Check Belongs — Gateway, BFF, and Domain Service required
- ABAC and resource ownership checks in Spring required
- Service-to-service authentication: mTLS and Client Credentials required
- PII and secrets — how not to leak them into logs, responses, and messages
- Auditing administrator actions
- PCI DSS for developers
- GDPR for Developers
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 16. Brokers and distributed systems · 66 questions
AMQP/RabbitMQ, Kafka and distributed patterns: saga, outbox, idempotency.
- The AMQP protocol: exchange, queue, binding, ack required
- RabbitMQ in production: clustering, queue types and monitoring
- Spring AMQP: sending and receiving messages through RabbitMQ required
- Messaging Patterns with AMQP
- AMQP vs Kafka: which broker to choose required
- Apache Kafka: topics, partitions, ordering and guarantees required
- Kafka in production: Spring Kafka, DLQ, Schema Registry, tuning, security required
- Kafka Streams: stream processing
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 17. Microservices: architecture and pitfalls · 53 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 required
- 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
- Resilience Patterns: Retry, Circuit Breaker, Bulkhead, DLQ required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 18. Containers: Docker · 38 questions
Containers and images, Dockerfile for Spring Boot, multi-stage builds, running containers, volumes and data, networking, Docker Compose, the JVM 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 for Spring Boot: building the image the right way required
- Docker Multi-Stage Builds and Layer Caching required
- Running containers: docker run and the lifecycle required
- 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
- JVM in a container: memory and cores required
- Small and Secure Docker Images
- Image Registries and Building in CI
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 19. Kubernetes and graceful shutdown · 59 questions
Cluster, networking, Spring Boot on Kubernetes, deployment and graceful shutdown.
- Kubernetes: pod, deployment, service — where to start required
- Networking in Kubernetes: Service, DNS, Ingress, NetworkPolicy required
- Spring Boot on Kubernetes: probes, resources and the JVM, graceful shutdown 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
- Graceful shutdown in Spring Boot: server.shutdown, timeouts, and health probes required
- HTTP drain — preStop sleep and long-running endpoints required
- Database and persistence during Spring Boot shutdown required
- Scheduled, @Async, and outbox: how to stop background tasks correctly
- Kafka shutdown — how to stop the consumer and producer correctly
- Idempotency during service shutdown
- Kubernetes and graceful shutdown: terminationGracePeriodSeconds, probes, maxSurge required
- Shutdown budgets and graceful shutdown observability
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 20. Clouds · 141 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
- AWS from Spring Boot: SDK v2, the credentials chain and LocalStack required
- Security and observability in AWS: Secrets Manager, SSM, KMS, CloudWatch required
- Resilience and Disaster Recovery in AWS
- AWS cost optimization: where to start
- 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 21. CI/CD: the delivery pipeline · 30 questions
Pipeline principles, CI for Java, release strategies and branching.
-
Phase 22. Quality: test strategy · 32 questions
The test pyramid, slices and integration tests, mocks and external services, load testing.
-
Phase 23. Observability and diagnostics · 62 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.
- Spring Actuator, Micrometer, tracing required
- Logging in Java and Spring Boot: JSON, MDC and Log Levels required
- Metrics in Spring Boot: Micrometer and Prometheus required
- Distributed tracing in Java: OpenTelemetry, spans, and how to link logs with traces required
- Context propagation and MDC in Spring Boot
- Health checks in Spring Boot: liveness, readiness and custom HealthIndicator
- SLO and Alerts in Java/Spring Boot
- Observability configuration in Spring Boot
- Профилирование и утечки required
- Thread dump и heap dump required
- От алерта до строки лога required
- PostgreSQL monitoring: slow queries, activity, and key metrics required
- Отчёт нагрузки (pg_profile) required
- Запросы для отчёта нагрузки required
- Постмортем и дежурства required
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 24. Working with AI agents · 36 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
- Phase test in the cabinet
-
Phase 25. Building LLM applications · 32 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 26. System design and architectural choices · 56 questions
The design method, building blocks, storage and notation choices, C4.
- Reliability, scalability, maintainability — in plain words required
- The system design method: from requirements to architecture required
- Building Blocks of System Design required
- How a Notification System Works: Architecture From Scratch
- How to write and defend a system design: design doc, C4, review required
- Spring MVC, WebFlux and virtual threads: which to choose
- ADR: how to record architecture decisions required
- The Architect's Role in a Development Team required
- C4 model
- Spring Cloud or Kubernetes
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 27. Domain-Driven Design · 26 questions
Strategic and tactical DDD patterns, aggregates, domain events.
- What DDD Is and Why You Need It required
- Strategic DDD Patterns required
- DDD Tactical Patterns required
- DDD Integration Patterns
- Design Principles in DDD
- Ontology and the domain model: a system of concepts before aggregates
- Event Storming: extracting the domain model from the business
- Phase test in the cabinet
-
Phase 28. Service architecture patterns · 67 questions
Service and microservice structure, Onion and Hexagonal, CQRS, resilience and batch processing.
- Onion Architecture required
- CQRS
- When to use CQRS: from simple markers to separate databases required
- The command side in CQRS — how writes work required
- Query side in CQRS: reading data without write tools required
- Read model in CQRS — a denormalized projection for fast reads required
- Syncing the read-model through events: outbox, Kafka, and the idempotent consumer
- CQRS Maturity Level and Evolution — From Simple Split to Event-Driven Read Model
- Hexagonal architecture
- When to Use Hexagonal Architecture required
- The Core Layer in Hexagonal Architecture required
- Ports in Hexagonal Architecture — interfaces in core/ required
- Inbound Adapters in Hexagonal Architecture — REST, Kafka, CLI required
- Outbound Adapters in Hexagonal Architecture — How a Service Talks to the Outside World required
- Module Structure in Hexagonal Architecture
- Bootstrap / Composition Root in Hexagonal
- Architecture Tests in a Hexagonal Project with ArchUnit
- Batch Data Processing: How Not to Break Your Background Worker
- Event Sourcing: Store Events, Not State
- Что это и когда нужны
- Реализация в Java
- BPM и Camunda
- Mock interview in the cabinet
- Phase test in the cabinet
-
Phase 29. 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
-
Phase 30. Kotlin for the Java developer · 39 questions
A second JVM language: syntax and idioms, null-safety, data and sealed classes, extension functions, coroutines vs virtual threads, and Spring Boot with Kotlin. Optional phase.
- Зачем Kotlin required
- Синтаксис required
- Null-safety required
- Классы: data, sealed, object required
- Функции и коллекции
- Корутины
- Kotlin и Spring Boot
- Phase test in the cabinet
-
Phase 31. The product engineer: role and practice · 43 questions
The whole role: start from the user problem, outcome metrics and end-to-end ownership — plus working with an AI agent, the domain model and the path from slice to contract.
- Who a Product Engineer Is: The Role and the Work Cycle required
- The Problem, Not the Solution required
- Contact with the User
- Outcome Metrics, Not Output Metrics required
- Prioritization: the smallest valuable slice required
- Ownership from idea to user required
- Shipping and the Metrics Loop, Solo
- 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
- 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 · 34 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 required
- Use Case specification: the format required
- Maturity level 0: a snapshot of existing code
- Maturity Level 1: Layered required
- Maturity Level 2: UseCase + Handler required
- Maturity Level 3: DDD + Hexagonal required
- Case study: a marketplace — how I understood the task
- How to Split a System into Services: A Marketplace Map required
- 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
Программа обучения v14.1.97
Backend · Java
This site is built as a training program. Every article is a piece of the knowledge you need to work on a team that uses the Use Case Pattern. The program moves from Spring fundamentals through data, design principles and patterns, search and storage, infrastructure and quality to architectural thinking — system design and DDD — culminating in the Use Case Pattern, and finally an end-to-end marketplace case study.
The program has 1622 self-check questions in total.