-
Phase 1. Language basics: Java · 18 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
- OOP in Java: classes, inheritance, interfaces, record and enum
- Java Collections: Lists, Sets and Maps
- How HashMap Works Inside
- Generics in Java: type safety without casting
- Exceptions in Java: hierarchy, checked/unchecked, try-with-resources
- Lambdas and the Stream API in Java
- Records, Optional, and modern Java
- Garbage Collection in Java
- Java Tooling: JDK, javac, jar, Maven and Gradle
Take the phase quiz → self-check after reading the phase
-
Phase 2. Git and branching models · 8 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
- 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
Take the phase quiz → self-check after reading the phase
-
Phase 3. Foundation: Spring core · 19 questions
DI/IoC, bean lifecycle, Boot, MVC, Data JPA, transactions, events, AOP, scheduler.
- Spring DI/IoC, bean lifecycle, and scopes
- Spring Bean Lifecycle with Examples
- Spring Boot auto-configuration, properties, profiles
- Spring MVC: Controllers, REST, Validation and Error Handling
- @Transactional in Spring: transactions, propagation, pitfalls
- Spring Data JPA: repositories, query methods, projections, N+1
- Spring Events: @EventListener, @TransactionalEventListener, asynchronous events
- Spring AOP: aspects, proxies and why @Transactional sometimes stays silent
- Spring Scheduled, Async, virtual threads
Take the phase quiz → self-check after reading the phase
-
Phase 4. Multithreading and concurrency · 16 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
- Java Memory Model (JMM): Visibility and happens-before
- Races in multithreaded programs: race condition and data race
- synchronized and monitors: mutual exclusion in Java
- Explicit Locks: Lock and ReentrantLock
- Atomic Variables and CAS in Java
- Thread-Safe Collections in Java
- Thread Pools: ExecutorService
- CompletableFuture: Asynchronous Tasks in Java
- Virtual Threads in Java 21
- Deadlock, livelock, and starvation: when threads get in each other's way
Take the phase quiz → self-check after reading the phase
-
Phase 5. PostgreSQL: model and queries · 21 questions
Transactions and isolation, locking, data types, indexes and EXPLAIN.
- ACID and Transaction Isolation Levels in PostgreSQL
- Transaction Isolation Levels in PostgreSQL
- Spring @Transactional: how transactions work and where they break
- 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
- How to Choose an Index and Estimate Selectivity in PostgreSQL
- EXPLAIN ANALYZE — how to read a PostgreSQL query plan
Take the phase quiz → self-check after reading the phase
-
Phase 6. PostgreSQL: operations and scale · 19 questions
Migrations, connection pool, vacuum/WAL, replication, backup, partitioning, FTS and geo.
- 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
- PostgreSQL monitoring: slow queries, activity, and key metrics
- 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
Take the phase quiz → self-check after reading the phase
-
Phase 7. Hibernate and ORM · 17 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
- Entity Mapping in Hibernate and JPA
- Entity Associations in Hibernate: @OneToMany, @ManyToOne, @ManyToMany
- Persistence context and entity states in Hibernate
- Lazy and Eager Loading in Hibernate
- The N+1 Query Problem in Hibernate
- JPQL, Criteria API, and Native Queries in Hibernate
- Caching in Hibernate: first-level, second-level and query cache
- Transactions, flush, and locking in Hibernate
- Entity Inheritance in Hibernate: SINGLE_TABLE, JOINED, TABLE_PER_CLASS
- Common Hibernate mistakes: what goes wrong and how to fix it
Take the phase quiz → self-check after reading the phase
-
Phase 8. Other stores: documents, search, files, analytics · 23 questions
MongoDB, Elasticsearch, object storage (S3) and ClickHouse.
- ACID, read and write concerns, transactions in MongoDB
- Document modeling in MongoDB: embed vs reference, indexes
- Replication and Sharding in MongoDB
- Elasticsearch: how a search engine works
- How Queries Work in Elasticsearch and Why Documents Are Ranked the Way They Are
- 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
- 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
- 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
- Redis in Spring Boot: RedisTemplate, @Cacheable and Spring Session
- Operating Redis: persistence, memory, replication
- How ClickHouse Works: Columnar Storage, MergeTree, and OLAP
- ClickHouse: schema modeling, queries, materialized views
- ClickHouse from Java and Spring Boot: connecting, writing, and reading
- ClickHouse in production: replication, TTL, backups and monitoring
Take the phase quiz → self-check after reading the phase
-
Phase 9. Design principles and patterns · 9 questions
SOLID, GRASP, GoF patterns, DRY/KISS/YAGNI.
- SOLID: five principles of design
- GoF Patterns: All 23 in Plain Words
- GRASP: Assigning Responsibilities
- DRY, KISS, YAGNI and other engineering principles
Take the phase quiz → self-check after reading the phase
-
Phase 10. Networking fundamentals · 9 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
- 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
- Load Balancers and Reverse Proxies
- Networking and Reliability: Timeouts, Retries, Idempotency
Take the phase quiz → self-check after reading the phase
-
Phase 11. API: REST and contracts · 22 questions
URLs and resources, query parameters, responses and errors, versioning, OpenAPI.
- REST URLs and resources: how to name paths and pick HTTP methods
- Query Parameters and Pagination in a REST API
- JSON and Response Format in REST API
- Errors in REST API — the Problem Details format
- HTTP Headers in REST API: Content-Type, Authorization, Idempotency-Key, and Tracing
- REST API versioning — how to change an API without breaking clients
- Alias segments and action endpoints in REST API
- API-first and contract-first: design the contract before the code
- 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
- GraphQL: The Client Asks for Exactly What It Needs
- HATEOAS: REST Maturity and Hyperlinks
- Where to Validate Data
- Bean Validation in Spring: @NotNull, @Valid and MethodArgumentNotValidException
- Custom Constraints and Error Messages
- Application error model
- A single error handler
- Common Pitfalls in Exception Handling
Take the phase quiz → self-check after reading the phase
-
Phase 12. Security and authorization · 19 questions
Spring Security, Keycloak/OAuth2/OIDC and authorization patterns.
- Spring Security: filters, AuthN, AuthZ, OAuth2
- 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
- Keycloak and Spring Security: validating tokens
- Roles and Access: RBAC and ABAC with Keycloak
- Three Keycloak tokens: access, id, refresh — which goes where
- Authentication and authorization patterns
- Where Each Check Belongs — Gateway, BFF, and Domain Service
- ABAC and resource ownership checks in Spring
- Service-to-service authentication: mTLS and Client Credentials
- PII and secrets — how not to leak them into logs, responses, and messages
- Auditing administrator actions
Take the phase quiz → self-check after reading the phase
-
Phase 13. Brokers and distributed systems · 15 questions
AMQP/RabbitMQ, Kafka and distributed patterns: saga, outbox, idempotency.
- The AMQP protocol: exchange, queue, binding, ack
- RabbitMQ in production: clustering, queue types and monitoring
- Spring AMQP: sending and receiving messages through RabbitMQ
- Messaging Patterns with AMQP
- AMQP vs Kafka: which broker to choose
- Apache Kafka: topics, partitions, ordering and guarantees
- Kafka in production: Spring Kafka, DLQ, Schema Registry, tuning, security
- Distributed patterns: data consistency across services
Take the phase quiz → self-check after reading the phase
-
Phase 14. Containers: Docker · 15 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
- Images, layers and the Dockerfile: how Docker packages an application
- Dockerfile for Spring Boot: building the image the right way
- 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
- JVM in a container: memory and cores
- Small and Secure Docker Images
- Image Registries and Building in CI
Take the phase quiz → self-check after reading the phase
-
Phase 15. Kubernetes and graceful shutdown · 19 questions
Cluster, networking, Spring Boot on Kubernetes, deployment and graceful shutdown.
- Kubernetes: pod, deployment, service — where to start
- Networking in Kubernetes: Service, DNS, Ingress, NetworkPolicy
- Spring Boot on Kubernetes: probes, resources and the JVM, graceful shutdown
- Deploying to Kubernetes: manifests, Helm, rolling update, GitOps
- Kubernetes in practice: debugging pods and kubectl commands
- Graceful shutdown in Spring Boot: server.shutdown, timeouts, and health probes
- HTTP drain — preStop sleep and long-running endpoints
- Database and persistence during Spring Boot shutdown
- 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
- Shutdown budgets and graceful shutdown observability
Take the phase quiz → self-check after reading the phase
-
Phase 16. Cloud: AWS · 20 questions
Networking, IAM, compute, scaling, serverless, data, IaC and well-architected.
- 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
- AWS from Spring Boot: SDK v2, the credentials chain and LocalStack
- Security and observability in AWS: Secrets Manager, SSM, KMS, CloudWatch
- Resilience and Disaster Recovery in AWS
- AWS cost optimization: where to start
- 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
Take the phase quiz → self-check after reading the phase
-
Phase 17. CI/CD: the delivery pipeline · 9 questions
Pipeline principles, CI for Java, release strategies and branching.
- CI/CD principles: the pipeline from commit to production
- CI for Java/Spring: build, tests, quality gates
- Release strategies: rolling, blue-green, canary, feature flags
- Branching and the release cycle: trunk-based, versions, GitOps
Take the phase quiz → self-check after reading the phase
-
Phase 18. Quality: testing and observability · 16 questions
Test strategy and observability/Actuator.
- Spring Testing: @SpringBootTest, slices, TestContainers
- The test pyramid: what goes where
- Integration Tests with Testcontainers
- Mocks and External Systems in Tests
- Spring Actuator, Micrometer, tracing
- Logging in Java and Spring Boot: JSON, MDC and Log Levels
- Metrics in Spring Boot: Micrometer and Prometheus
- Distributed tracing in Java: OpenTelemetry, spans, and how to link logs with traces
- 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
Take the phase quiz → self-check after reading the phase
-
Phase 19. System design and architectural choices · 17 questions
The design method, building blocks, storage and notation choices, C4.
- 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
- Choosing your starting architecture: monolith, modular monolith, microservices
- PostgreSQL or MongoDB: how to choose a database
- PostgreSQL or ClickHouse: when to add a second database
- Search: PostgreSQL FTS or Elasticsearch
- Files: in the database or in object storage
- Between services: synchronous call or events
- Spring MVC, WebFlux and virtual threads: which to choose
- ADR: how to record architecture decisions
- The Architect's Role in a Development Team
- C4 model
Take the phase quiz → self-check after reading the phase
-
Phase 20. Domain-Driven Design · 10 questions
Strategic and tactical DDD patterns, aggregates, domain events.
- What DDD Is and Why You Need It
- Strategic DDD Patterns
- DDD Tactical Patterns
- DDD Integration Patterns
- Design Principles in DDD
Take the phase quiz → self-check after reading the phase
-
Phase 21. Service architecture patterns · 21 questions
Service and microservice structure, Onion and Hexagonal, CQRS, resilience and batch processing.
- Onion Architecture
- CQRS
- When to use CQRS: from simple markers to separate databases
- The command side in CQRS — how writes work
- Query side in CQRS: reading data without write tools
- Read model in CQRS — a denormalized projection for fast reads
- 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
- The Core Layer in Hexagonal Architecture
- Ports in Hexagonal Architecture — interfaces in core/
- Inbound Adapters in Hexagonal Architecture — REST, Kafka, CLI
- Outbound Adapters in Hexagonal Architecture — How a Service Talks to the Outside World
- Module Structure in Hexagonal Architecture
- Bootstrap / Composition Root in Hexagonal
- Architecture Tests in a Hexagonal Project with ArchUnit
- Structural Patterns for Microservices
- Resilience Patterns: Retry, Circuit Breaker, Bulkhead, DLQ
- Batch Data Processing: How Not to Break Your Background Worker
- Event Sourcing: Store Events, Not State
Take the phase quiz → self-check after reading the phase
Программа обучения v2.1.2
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 342 self-check questions in total.