This training list is taken from dev.courses on . New courses may be available — check dev.courses for the latest additions.

Clean Code: The Next Level

Advanced Clean Code certification training for Java developers, covering the latest Java principles, design patterns, and architecture best practices for designing clean, modular, domain-driven applications.

Introduction

During this training, you'll master advanced design patterns and architectural best practices for building clean enterprise applications that don't suffer from unjustifed complexity so common in enterprise Java.

From advanced OOP and FP principles, to domain-driven design, and modern enterprise architecture patterns, you’ll learn to apply the underlying principles in your Java projects, pragmatically and incrementally, without major rewrites.

Day 1 ⋅ Code Design Principles and Patterns

• Master the art of effective naming.
• Identify the right level of abstraction.
• Use cognitive load as a driver for refactoring.
• Find the balance between specific and abstract code.
• Apply just-enough design and Lean code.
• Leverage reification in your design.
• Avoid premature abstractions (AHA and WET principles).
• Mix OOP with functional programming like a pro.
• Don't scatter things too much (Locality of Behaviour).
• Maintain consistent level of abstraction in your code (SLAP).
• Treat SOLID, DRY, YAGNI, and the Law of Demeter as guidelines, not laws.
• Eliminate NPEs with null-safe programming.
• Organize code following The Stepdown Rule.
• Replace getters with Queries.
• Replace setters with Domain Methods.
• Flatten conditionals with Monads.
• Move from procedural design to Elegant Objects.
• Cure primitive obsession with Value Objects.
• Replace try-catch clauses with pluggable exception handling strategies.
• Design data classes with Lombok, Immutables and pure Java.
• Enhance Java collections with Guava and StreamEx.
• Implement thread-safe lazy loading with Memoization.
• Master advanced dependency injection patterns with Spring.
• Learn principles for effective code packaging.
• Test-drive components with Spock.

Day 2 ⋅ Architecture Principles and Patterns

• Slice and structure your application by Features (Vertical Slice Architecture).
• Modernize your application layer with the Mediator pattern.
• Enable tracing, logging, and transactions for your app layer (without AOP, proxies, and other black magic).
• Separate commands from queries with CQRS.
• Mark clear boundaries between layers.
• Map the domain to the API DTOs (and stay away from auto-mappers).
• Design rich domain models with OO and FP patterns.
• Break down God Objects with advanced DDD patterns (Specifications / Queries / Events / State Passing / Multimapping).
• Connect domain entities with fast Event Bus (ForkJoinPool, Caffeine, and Springleton pattern).
• Consolidate business rule validation in the domain model.
• Run validation across all layers w/o duplicating the logic or triggering validation twice.
• Move long-running processes into background with the Transactional Outbox.
• Turn your relational database into a robust message queue.
• Ensure jobs run once across the cluster by leveraging database locking.
• Design a flexible data access layer (DAO, Repository, Unit of Work, Finder, Projection patterns).
• Expose data safely and securely via public API (encryption, tokenization, UUIDs, ULIDs, Squids).
• Optimize query performance by using a separate read model (JPA / jOOQ / JDBI).
• Keep data safe under high-load scenarios by understanding tx locking, isolation modes, and trade-offs.
• Make your application fault tolerant with Resilience Patterns (Resilience4j / Failsafe).
• Enforce architectural constraints with ArchUnit.

Design Patterns and Principles

This live online course will give you a solid grasp of today’s most important software design patterns, the principles behind them, and the tradeoffs they bring. You’ll learn to identify patterns suited to real-world problems, evaluate design alternatives, and make informed architectural decisions.

Introduction

Mastering design patterns helps you understand existing code, evaluate design alternatives, and communicate ideas more effectively with teammates and architects. This code-driven workshop emphasizes timeless design principles over textbook definitions, covering patterns from basic (like Singleton and Strategy) to strategic (like Visitor and Saga). Through hands-on exploration of real-world tradeoffs and alternatives, you’ll build a practical toolkit for writing cleaner, simpler code. You'll also dive into patterns behind modern frameworks and inter-system collaboration, culminating in a pragmatic, code-first take on Clean Architecture.

This online training is for developers who can read Java (or languages like PHP, C#, TypeScript, Scala, or Kotlin) and want to strengthen their design skills. It’s ideal if you're aiming for an architect role, planning to design a new system, or looking to critically review and improve an existing one.

IMPORTANT This course is primarily tailored for backend developers working with Java, Kotlin, Scala (often with Spring), C#, or PHP.

Agenda

Forking behavior

• Strategy (OOP) vs FP alternative vs Chain of Responsibility (aka “Filters” Pattern)
• Template Method (OOP) vs Passing-a-Function (FP) + variations (Loan Pattern)
• Visitor Pattern vs Matching Sealed Classes (Java21,Scala,Kotlin)
• State Machines & the State Pattern

Intercepting Calls

• Decorator,
• Proxy (OOP)
• Aspect Oriented Programming (AOP) and Execute-Around (FP)

Creating Objects

• Factory Method
• Singleton, Dependency Injection, Object Pool - overview
• Builder – pattern or anti-pattern?

Propagating Change

• Observer Pattern: in-memory (eg Spring Events) or messaging
• Command Pattern: in-memory (eg tasks to thread pool) or messaging
• Observer vs Command

Wrap-up

• Anti-Patterns + typical workarounds
• Recap & Quiz

Event-Driven Architectures

This 2-day course covers the fundamentals of Event-Driven Architectures, focusing on scalable, fault-tolerant systems. You'll learn about key tools like RabbitMQ and Kafka, with practical exercises to design and assess architectural solutions.

Introduction

Event-driven architectures can help build autonomous, scalable and fault-tolerant systems. However, like any architecture, it has distinctive features that can cause far-reaching complications if not understood well. Join this training to gain a deep understanding of the fundamental concepts as well as patterns and pitfalls of Event-Driven Architectures. Developers of any programming language can attend, because the focus will stay on a pragmatic understanding of architectures and tools rather than specific implementations. The acquired skills will allow participants to correctly design architectural solutions and perform thorough tradeoff analysis and risk assessments. You’ll also learn how tools like RabbitMQ, Kafka, and Cloud-Native messaging systems differ and how selecting them can impact your architecture.

During the training, you can expect explanations in simple terms, accompanied by suggestive visuals and real-world analogies that will help you easily understand and remember complex topics. The teaching style will be highly interactive, with plenty of debates to engage in. You'll have endless opportunities to discuss issues that are of interest to you, and there will be many simple exercises to apply the concepts you learn.

Agenda

Event Storming

• Workshop with non-tech PO/BA/BIZ (2h, optional)
• Overview of Event-Driven Architectures
• Comparison with classic synchronous communication (like REST)
• Message Delivery Guarantees for reliable communication between services
• Events vs Commands 💬 Quiz
• Dual Write Problem: update DB + send message 🛠️Outbox Table
• Messaging Idempotency: handling duplicated messages 🛠️Inbox Table
• Order of Events: when it's essential, and when not 🛠️Resequencer
• Event modeling & metadata
• Types of Events: ° Domain, Integration, Delta, Workflow...
• Kafka fundamentals, best practices and pitfalls 🛠️Repartition to preserve message order
• CQRS 🛠️Create a Read Projection based on events
• Types of data consistency: Strong, Eventual, Causal Consistency
• Orchestration, Choreography and the Saga Pattern 🛠️Use a compensating transcation
• Auditability, Metrics, Tracing
• Basics of Event-Sourcing: Pros/Cons, implementation options
• Event Schema Migration, backwards/forwards compatibility 🛠️Upcaster
• Introduction to Event-Streaming 🛠️Splitter & Aggregator using KStream/KSQL
• Migration strategies from synchronous communication to event-driven architectures

Event Sourcing (optional)

• Event Storming Exercise
• Event-Sourcing Mindset
• Commands apply changes via emitting Events
• Events as the Source of Truth
• Aggregates: mutable or immutable
• Event Store: append-only log of events; key features
• Command Validation
• Read Projections
• Event Schema Versioning
• Concurrency Control
• Snapshots: design options

Kafka Streams (optional)

• Basic Operations
• Joining and KTables
• Aggregation and Time Windows
• Testing
• Exception Handling
• Processor API
• Interactive Queries

JPA and Hibernate

For developers who thought they knew Hibernate—until performance issues or JPA magic bugs led them to this training. Gain a deep, practical understanding of JPA and Hibernate to write faster, safer, and more predictable code.

Introduction

This training will give you a clear understanding of Hibernate’s powerful features and how to avoid its most common pitfalls. You’ll learn to recognize key ORM performance traps, understand transaction control, and perform efficient mass data inserts. By the end, you’ll be able to trace and fix common performance bottlenecks, write efficient and maintainable read queries, optimize updates and batch operations, and design rich, efficient ORM entity models. This training is ideal for developers who have worked with Hibernate but feel they’re missing insight into its inner workings. Prior experience with fixing SQL performance issues is helpful but not required.

Agenda

Efficient Reading & Searching

• Eager vs Lazy Loading
• JPA 1st Level Cache
• N+1 Queries problem & fixes
• Paginated searches best practices
• Hierarchical Data Processing
• Dynamic queries: JPQL+=, Criteria ±metamodel, specifications, conditional JPQL, and QueryDSL

Rich & Performant Entity Model

• Deep (@Embedded), Guarded Entities (DDD-style) with Semantic IDs
• Primitive vs Reference Entity vs enum
• Challenging JPA Links: bidirectional, and @ManyToOne
• Entity hashCode/equals fallacy
• Best practices storing files in DB (CLOB/BLOB)

Efficient Transactions

• Transactional mechanics, propagation, rollback, after commit hooks
• Dirty checks, auto-flushing & write-behind
• How to detect and avoid JDBC Connection Pool Starvation
• Transaction control best practices

Updating Entities

• Concurrency Control using Optimistic and Pessimistic locks
• Generating Primary Key efficiently
• Demo: High-performance JPA data import using Spring Batch
• [optional] Bulk update JPQL queries - pitfalls

Caching (optional)

• Hibernate Second-level cache for Entities and Queries
• Comparison with Spring's @Cacheable

Java Clean Architecture

Practical, pragmatic, and realistic Clean Architecture certification training for Java developers building large-scale applications.

Introduction

This training will guide you through the major architectural styles and patterns for backend systems, including Clean Architecture, Hexagonal Architecture, Layered Architecture, Vertical Slices Architecture, Domain-Driven Design, Modular Monoliths, and Microservices. By understanding every style and its trade-offs, you’ll learn how to combine them in your application while avoiding common pitfalls. Guided by real-world Java examples, you’ll learn how to:

Day 1 ⋅ Design clean and pragmatic architecture

• Slice and structure your application by Features.
• Group code by the axis of change.
• Organize code in functional top-level packages.
• Find package boundaries (heuristics).
• Remove cyclic dependencies between packages (6 strategies).
• Separate module/compilation units.
• Decouple modules/packages/components with Dependency Inversion.
• Reduce cognitive load with modularity and information hiding.
• Enforce architectural constraints.
• Isolate the core application logic from the infrastructure.
• Test your core logic, infrastructure, and integrations.
• Segregate data structures and DB Schemas.
• Balance between uniformity/standardization and pragmatism.
• Leverage Evolutionary Architecture and avoid big up-front designs.
• Incrementally migrate from legacy Big Ball of Mud to Modulith/Microservices.

Day 2 ⋅ Design clean services and domain model

• Apply SOLID Principles and Five Rules of Simple Design.
• Masterfully balance coupling and cohesion.
• Make your code speak the domain language.
• Separate the core domain from subdomains.
• Decouple domains with APIs and events.
• Design rich domain entities (OOP done right).
• Protect domain objects’ invariants (strategies).
• Decouple the domain from the infrastructure, API, and persistence.
• Create an Anti-Corruption Layer with Adapter pattern.
• Test-drive the domain with fast unit tests.
• Map the domain to the API DTOs (and stay away from auto-mappers).
• Separate logic by Layers of Abstraction.
• Design Application Services, Controllers, and Façades.
• Logically separate commands from queries with CQRS.
• Improve query performance by using a separate read model.
• Keep write and read models in sync.

By the end of this course, you’ll be able to mix and apply essential architectural styles – Clean-, Hexagonal-, Layered-, Onion-, Screaming-, and Vertical Slices- Architectures, Domain-Driven Design, Microservices, Monolith, and Modular Monoliths. You’ll develop a firm understanding of the underlying architectural principles and learn how to implement them in your Java applications incrementally, as necessary, without big rewrites.

Java Performance

A 3-day course on Java tuning, metrics, profiling, concurrency, memory management, and JVM internals, illustrated through real-world performance experiments.

Introduction

A deep dive in Tuning Java Applications, Metrics, Profiling and Benchmarking, Concurrency and Memory Management, spiced with under-the-hood JVM details and debates around common performance issues of Java projects illustrated via a series of experiments distilled from real-life scenarios of hundreds of projects.

Agenda

Day 1

Round Table

• war stories from participants

Tracing a Latency Bottleneck

• Metrics: exposing and understanding Timers, Counters, Gauges, Percentiles
• Java Flight Recorder (JFR): sample-based execution profiling, standard & custom JFR Events
• Profiling using Glowroot, JMC, IntelliJ or jProfiler
• Load testing using jMeter or Gatling: strategies, goals, pitfalls
• Exercise: Trace common bottlenecks in a Spring Boot application
• Distributed request tracing and time budgeting with Zipkin or Opentelemtry

Day 2

Java Concurrency

• Thread Pool: mechanics, parameters, usage patterns, monitoring
• Risks of multi*threading: race bugs, deadlocks, thread pool starvation
• Blocking concurrency control with atomic primitives, synchronized blocks and collections
• Non-blocking concurrency with CompletableFuture and/or Reactive Programming (see my other training)
• Spring Framework support: ThreadPoolTaskExecutor, @Async, non-blocking REST Calls & Endpoints
• Parallel Stream: when [not] to use?
• Thread Local: best practices, thread hopping
• Virtual Threads: pros/cons/pitfalls

Day 3

Memory Management

• Garbage Collector: GC mechanics, ways it can hurt you, monitoring, GC types, Java Memory Model
• Heap dump analysis: retained/shallow heap, GC Roots, profiling allocations
• Exercise: Tracing 10 types of Memory Leaks (You can already investigate some heap dumps here)
• Memory Efficiency Coding: data streamlining techniques
• Caching: principles, parameters, risks (optional)

Just-In-Time (JIT) Compiler

• JIT mechanics, dynamic optimizations
• GraalVM nativeimage
• Exercise: Writing micro-benchmarks with Java Measuring Harness (JMH) and/or JUnitPerf

Wrap-up:

• Performance Tuning Summary
• Bottleneck Tracing Overview
• Tradeoffs: latency/throughput/consistency/complexity

Kafka

A comprehensive dive into Kafka best practices, covering fundamentals, Java clients, testing, eventual consistency patterns, Kafka Streams, and performance tuning, with real-world examples and insights to help you master messaging systems and improve your architecture.

Introduction

In this comprehensive workshop, we will explore Kafka from the ground up, covering everything from fundamental concepts to advanced performance tuning. We’ll dive into Java clients, KafkaTemplate, @KafkaListener, and error handling mechanisms such as retries and dead-letter queues. Additionally, we’ll look at event schema management, Avro integration, and schema registry.

By the end of this course, you’ll have the skills and knowledge to tackle real-world Kafka use cases, optimize performance, and integrate Kafka seamlessly into your systems.

Agenda

Fundamentals

• Producer, Topic, partition, replication, consumer group/instance/offsets/rebalancing
• Fault-tolerance on producer, broker, consumer: core config props
• Manage topics, produce, and consume messages using Kafka CLI and IntelliJ Plugin

Java Clients

• KafkaProducer / KafkaConsumer in in kafka client
• KafkaTemplate and sending patterns
• @KafkaListener and error handling: log, sync retry, delayed retry, dead-letter
• Spring Cloud Stream Function (optional)
• Message Tracing with Spring-Kafka Interceptors
• Event Schema: versioning, creating an upcaster/downcaster
• Intro to Avro / Schema Registry

Testing

• Separating business logic tests from Kafka with spy beans
• Embedded Kafka
• Testing against a standalone or Testcontainer-ed Kafka Broker

Review Code Samples from Audience

Eventual Consistency Patterns

• Handling duplicated and out-of-order messages with Inbox Table
• Outbox Table
• Change Data Capture with Debezium / Kafka Connect

Kafka Streams

• Filter, Transform, Explore a record: Word Counter Kata
• Enriching data via API call or joining a KTable/GlobalKTable
• Branch and Merge streams
• Stateful operations: count, reduce, aggregate
• Designing maintainable aggregators (+many real-life applications)
• Time windowed aggregations: hopping, tumbling, sliding and session; stream-time and grace
• Query a KTable state store (CQRS)
• Processor API to read/write in state stores, and schedule tasks vs wall-clock-time
• Test Driver and controlling time

Tuning Kafka Performance

• Key Metrics to observe/alarm
• Performance best practices on Partitions, Producer, Consumer and Broker

Masterclass for technical team leads

Develop skills that every successful, effective, and trusted software development leader needs.

Introduction

What distinguishes a software developer from a software team lead? As a team leader, you are now in charge of people, their performance, and motivation. Your output is the output of your team.

In this training, you'll learn what does it take to be an exceptional tech lead, how to develop yourself as a leader, and how to maintain balance between leadership and technical duties. In a practical, down-to-earth style, you'll learn how to:

Day 1 ⋅ Develop Yourself as a Technical Lead & Build Great Teams

• Balance technical and non-technical skills
• Measure your progress as a leader
• Gain trust and respect
• Delegate effectively
• Communicate with confidence
• Influence others without resorting to issuing orders
• Motivate people with DRIVE
• Improve team's health
• Reclaim time for coding
• Design your teams using Team Topologies in mind
• Learn the seven qualities of a high performance team
• Measure your team's health and performance
• Foster a continuous learning culture in your team
• Understand the importance of mentoring
• Learn the six effective mentoring tools
• Understand and apply strategic pair programming
• Help your teammates reach career heights
• Don't fall into a "babysitter trap"

Day 2 ⋅ Improve the Development Process & Accelerate Hiring

• Learn to measure IT and team performance
• Learn how Scrum, Kanban, and Lean fit together
• Learn how to plan and deliver work always on time
• Learn to prioritize and split work properly
• Understand the power of Little's Law
• Deliver value sooner with Continuous Delivery
• Eliminate bottlenecks and wastes in your process
• Keep technical debt under control
• Deliver value, not just software features
• Don't hire like everybody else
• Design an effective, no-bullshit hiring process
• Ensure that only people who share your values apply
• Learn to assess technical and soft skills
• Scale hiring process through delegation and mentoring
• Become an interviewer that wins minds and hearts
• Turn every interviewee into your personal fan!
• Attract, retain, and grow A-class engineers
• Boost hiring effectiveness 5x. No kidding.

Modern Java Patterns

Discover the best new features of the Java language and learn modern design patterns enabled by them.

Introduction

This course offers a modern take on Java development, focusing on recent language enhancements and how they support cleaner, more expressive, and maintainable code.

Agenda

Functional Programming

• Advanced Stream use*cases
• Syntax quirks: method references, target typing, effectively final
• Exceptions: wrapping as runtime and the Try monad

Fighting NULL

• Null Object pattern
• Optional best practices & abuse
• Annotations

Immutability

• Records (17) and Data*Oriented Programming (DOP); best practices and limitations
• Do we still need Lombok?
• Immutable collections

Intercepting calls

• Proxy pattern (OOP)
• Aspect*Oriented Programming (AOP) – Spring example
• Execute*Around pattern (FP)

Forking behavior

• Strategy pattern
• Attaching behavior to enum
• Returnswitchenum pattern
• Filter pattern

Fill behavior bits

• Template Method pattern (OOP)
• Loan pattern (FP)

Behavior per subtype

• Visitor pattern (OOP)
• Switch on sealed classes

Concurrency

• Parallel stream (8) pitfalls
• CompletableFuture (8)
• Virtual Threads (Project Loom)
• Structured Concurrency

Strings:

• formatted, text blocks, interpolation

Interfaces with default and private methods – use-cases

Platform improvements: GraalVM and nativeimage, super-fast Garbage Collectors

Future of Java Language

Modern Software Engineering with TDD

Master the art of building modern, high-quality, maintainable software using Test-Driven Development (TDD) and Pragmatic Architecture, specifically tailored for developers building large-scale projects with the .NET stack.

Introduction

This training will guide you through the foundational practices of Test-Driven Development (TDD) – from its core principles to advanced concepts, common pitfalls, and applying it effectively to large-scale projects.

Through practical examples and hands-on lab work, you'll master real-world TDD to write cleaner code, better tests, move fast w/o breaking things, reduce technical debt, and foster a culture of technical excellence on your team.

Additionally, you'll explore how architectural best practices, like Vertical Slice Architecture, boost your TDD game, enabling even faster, safer, and more enjoyable software development.

What's under the hood?

Master TDD Fundamentals

• Understand the economics of TDD and how it enables faster and safer software development.
• Learn the essence of the Red-Green-Refactor cycle and the three laws of TDD.
• Overcome common obstacles to the Test-First approach and TDD flow.
• Design clear, simple, and testable code you and your teammates enjoy to read and use.
• Leverage Evolutionary Design to prevent big up-front designs.
• Reduce technical debt without big rewrites through Continuous Refactoring.
• Change complex code safely using Baby Steps and Microcommits.
• Eliminate manual debugging with short Feedback Loops.

Write better tests

• Learn the 7 most common test smells (and how to fix them).
• Write maintainable, domain-driven, and self-documenting tests.
• Identify the most suitable test types (e.g. unit vs. integration) using Testing Pyramid and Testing Diamond.
• Learn the five Test Doubles (Mock, Stub, Fake, Spy, Dummy) and when to apply each.
• Skillfully switch between Classical and Mockist test/TDD styles.
• Write fast and robust tests for repositories, file system, time and async code.
• Build and evolve fluent Test APIs for functional and acceptance testing.
• Measure the quality of your tests with Mutation Testing (and see why Code Coverage is a flawed metric).

Build .NET backend services with TDD

• Implement clean and maintainable Web APIs with a test-first approach.
• Apply SOLID principles to design modular and testable apps.
• Utilize the best .NET libraries and tools.
• Design Solitary and Sociable unit tests.
• Write Mocks and Stubs using the Moq library.
• Use Fluent Assertions to make clean test assertions.
• Leverage Docker to write reliable integration tests.
• Master the best practices of .NET Web API design.

Implement Pragmatic Architecture with .NET

• Understand the difference between centralized and Vertical Slice Architecture.
• Learn how Vertical Slice Architecture supports TDD.
• Discover the best design patterns to achieve clean .NET apps.
• Apply DDD with rich romain models.
• Utilize CQRS for clean separation of concerns.
• Optimize data operations with EntityFramework and Dapper.
• Apply the Mediator pattern with the famous MediatR .NET library.
• Learn how to write Architecture Tests.
• Learn how to improve your architecture incrementally, w/o revolutions and risky rewrites.

Advanced TDD Techniques

• Apply TDD effectively to legacy projects.
• Resolve the dilemma: "I need tests to refactor safely, but I need to refactor to write tests."
• Use Characterization and Approval testing to understand how legacy code works.
• Reproduce and fix production bugs using bug-driven TDD.
• Integrate TDD, ATDD, and BDD practices into QA teams.
• Understand the contextual trade-offs and when TDD may not be the best fit.
• Learn how to effectively explain, teach, and adopt TDD within your team. ... and much more. ⚡

By the end of this course, you’ll be able to confidently apply TDD on both brownfield (legacy) and greenfield (new) software projects. You'll have a firm understanding of deep synergy between testability and good design, and how TDD improves both. Finally, the course will shift your perspective on traditional software development, teaching you to deliver high-quality code quickly and sustainably, even under high-pressure conditions.

Modular Monolith

The Modular Monolith training teaches how to deploy decoupled modules as a single unit with a shared database, enabling independent teams to work efficiently while addressing key patterns and challenges in module encapsulation, data decoupling, and integration strategies.

Introduction

The Modular Monolith Architecture involves decoupled modules deployed as a single unit, connected to a single database, allowing independent teams to work side by side. This architecture is ideal for many projects today and serves as a necessary transition phase for migrating legacy codebases to microservices. Drawing from the experience of numerous successful real-world projects, this training will provide you with the tools and techniques needed to effectively adopt this architectural style, while also covering its core patterns and potential pitfalls, including module encapsulation, integration strategies, data decoupling, transaction boundaries, event-based integration, and more.

Key questions addressed in this training include strategies for migrating from a legacy monolith, whether a "Module" should be considered a build unit, how to determine the appropriate module size and scope, managing the release cycle in a Modulith, and deciding between shared or separate transactions

Day 1

Introduction

• Definition of a "Module"
• Technical vs Functional Code Partitioning

Code Decoupling

• Module internal and external API
• How to enforce Module Boundaries
• Exercise: Call another module via its published internal API

Module Integration Patterns

• Dependency Inversion & Plugin Pattern
• Event*based Integration
• Module Contract Segregation
• Aggregator Module
• The "shared" module: best practices and pitfalls
• Micro-frontends for full-stack module teams
• Exercise: Refactor a module cycle to several approaches above

Data Decoupling

• Stage #1: Single Writer per Table
• Database Refactoring: How to split a DB table in two
• Stage #2: Private Schemas
• Exercise: Join a foreign view in a Search
• Stage #3: Separate Consistency
• Exercise: Decouple Transactions with Async Calls or Events

Building and Testing

• From Packages to Build Modules (Maven/Gradle)
• Optimizing Release Cycle
• Exercise: Write a module-scoped test

From Module to Microservice

• Weaknesses of Modular Monolith
• Pros & Cons of Microservices
• Steps to extract a Module as a Microservice
• Architectural Quantum: Options between Monolith and Microservices

Practical Microservices

Microservices certification training for Java developers on designing, building, testing, and deploying production-grade microservices.

Introduction

This workshop equips you with the tools and knowledge required for building maintainable, scalable, and fault-tolerant Java microservices. You'll learn how to tackle real-world challenges like API design, observability, resilience, messaging, distributed consistency, and monolith migration—while avoiding pitfalls that teams face on their microservices journey.

Day 1 ⋅ Microservices Fundamentals, API Design, Integration Patterns & Eventual Consistency

• Introduction to microservices: definition, pros, cons, tradeoffs, and common pitfalls.
• Microservices vs. other architectural styles (Monolith/Modulith/Service-Based).
• Understanding the link between software architecture and team/org structure (Conway's Law).
• Taming Cognitive Load with Team Topologies: Stream-aligned, Platform Team, Component Team.
• Heuristics to find Service Boundaries.
• Balancing local and global complexity in distributed systems.
• REST API design principles and best practices.
• API backward compatibility and semantic versioning.
• CRUD APIs, Task-Based API, and CQRS.
• Contract-First vs. Code-First API design.
• Swagger and OpenAPI on client and server-side.
• Async HTTP.
• Batch APIs and Request Multiplexing.
• Error Handling.
• API Gateway: public vs private APIs.
• API Aggregator and GraphQL Federation. Integration
• Choosing appropriate conversation styles (sync RPC, async Messaging, Queues, Brokers, GraphQL, etc.)
• Handling messaging errors, duplicates, out-of-order, race conditions, sensitive, and lost messages.
• Queues vs. Commands vs. Events.
• Choreography vs Orchestration.
• Event Streaming with Apache Kafka — Fundamentals.
• Exercise: Redesign RPC/REST-based interactions to event-driven communication.
• CAP Theorem.
• Understanding ACID, BASE, and Eventual Consistency.
• Transactional Inbox & Outbox Pattern.
• Solutions to The Dual Write Problem.
• Change Data Capture (CDC) with Debezium.
• Why Distributed Transactions and XA are evil.
• Compensations and Reservations.
• Exercise: Design a Food Delivery App Saga.

Day 2 ⋅ Fault Tolerance, DevOps, Testing Strategies & Migrating to Microservices

• Blue/Green Deployment, Canary, and Feature Flags.
• Retries and Idempotency.
• Failover Cache.
• Timeout, Throttling, and Circuit Breaker.
• Containing Failures with Bulkhead Pattern.
• Sidecar Pattern with Istio Service Mesh.
• Exercise: Implement fault tolerance patterns with Spring/Resilience4j.
• Configuration management and service discovery.
• Log correlation with OpenTelemetry.
• Distributed Tracing with Zipkin.
• Metrics and Alarms with Grafana.
• Health Probes with Kubernetes Liveness and Readiness.
• Secret Management, Security Proxy/Chassis, Examples Security Architecture for Microservices.
• Exercise: Trace a bug, a bottleneck and a resource starvation in a microservice ecosystem.
• Testing microservices: how much and at what level?
• Honeycomb Testing Strategy (vs. Testing Pyramid).
• E2E testing against Staging and Service Mocks.
• Unit testing with real dependencies with Testcontainers.
• Consumer-Driven Contract Testing with Pact and Spring Cloud Contract.
• A step-by-step migration guide.
• Decomposition Patterns.
• Strangler Fig Pattern.
• Ten golden rules of Microservice Architecture.

Reactive Programming

This training is for you if your project uses Spring 5 WebFlux, you need to optimize a high-load API or batch workflow, or you've encountered bugs and challenges when working with Reactor. It’s also for you if you simply want to master one of the most complex programming paradigms in the world.

Introduction

The first challenge when approaching reactive programming is understanding why and when not to use it. Starting with ‘classic’ blocking web endpoints, we’ll benchmark the bottlenecks that occur under heavy load and then explore the various historical alternatives to Reactor. While we’ll examine dozens of operators, the focus will remain on understanding the signals that drive all reactive flows—this is key to unlocking the mysteries of backpressure, hot publishers, and avoiding common pitfalls when beginning to work with Reactor. We will then use this knowledge to approach several typical reactive flows, drawing conclusions about the best ways to write code that is maintainable and safe. After a comprehensive tour of Spring WebFlux features and quirks, we’ll move on to two tough tasks: testing reactive flows and progressively migrating blocking code to reactive flows. If time permits, we’ll also discuss performance tuning.

Agenda

Introduction

• [optional, basics] Recap: functional pipelines with Java8 Streams
• Blocking REST Endpoints: trace a thread pool starvation issue
• Alternatives to Reactive: CompletableFuture, coroutines(kt), Virtual Threads (Project Loom)
• Reactive Streams Spec
• Mono, Flux
• Understanding Marble Diagrams
• Signals: next, complete, error, request, subscribe, cancel

Core Operators

• Immediate: just, empty, error, never, range, fromIterable
• Delayed: delay, interval, delayElements
• Immediate Operators: distinct, filter, map, first, take, contains, all

Enriching Data

• flatMap vs concatMap vs flatMapSequential
• Batching requests: buffer, bufferWindow
• Handling Empty: defaultIfEmpty, switchIfEmpty
• Async filtering with.filterWhen
• Parallelizing work: Tuples, zip, zipWith, zipWhen
• Use-case Context design pattern

Performing Side Effects

• Fire-and-forget using doOnNext
• Parallelization, cancellation

[Hands-on] Migrating a blocking codebase to Reactive Programming

• Schedulers: CPU vs IO, best practices, ParallelFlux
• Calling blocking code in a safe way on boundedElastic scheduler
• CompletableFuture integration
• Bridging to a callback-based model: Sinks
• Reactive REST: Endpoints, and WebClient
• Reactive NoSQL: Mongo, Cassandra, Redis
• Reactive SQL: R2DBC
• Reactive Messages: send/receive
• Kafka Streams [optional]: KStream, KTable, Spring Cloud Stream Functions

Infinite Fluxes

• Preventing cancellation with onErrorContinue
• GroupedFlux
• Time series operators: scan, reduce, window, buffer, sample, merge, concat, combineLatest
• Hot vs Cold Publisher
• In-memory broadcast using Sinks
• Caching Hot Publishers: replay, cache, connect, autoConnect

Resilience

• Error handling patterns
• Timeout and Retry
• Back-pressure
• Throttling: rate-limiting, resilience4j integration
• Challenges of distributed systems under heavy load - brainstorming

Testing

• StepVerifier vs .block()
• TestPublisher
• PublisherProbe + custom extension
• Detecting blocking code with BlockHound
• Controlling Virtual Time [optional]

Debugging, Monitoring and Tuning

• Propagating metadata via Reactor Context
• Checkpoints and Hooks.onOperatorDebug
• Monitoring using .metrics, .elapsed, .timed

Common Pitfalls and Workarounds

• Not subscribing / Resubscribing to Cold Publisher
• Loosing Data Signals (empty)
• .subscribe()
• Blocking in non-blocking threads
• Unexpected Cancelation

Review of Code

• Sample from the audience

Secure Coding in Java

A practical workshop covering core cryptography and web security, OWASP top attacks with Spring fixes, and in-depth authentication and authorization using Spring Security framework.

Introduction

This training is for you if you've experienced security incidents in production, received a pen-test or audit and want to prevent recurring issues, or if your project requires early attention to security due to its sensitive nature. It's also suitable if you're seeking a review of your team's secure coding practices. Prior exposure to security concerns is recommended.

Agenda

Securing Applications with Spring

• Authentication: Form Login, Basic, API Token, Pre-Auth headers, JWT token
• Function-Level Authorization: URL-patterns and annotations, Role- vs Authority- based
• Spring Security Architecture, writing a custom filter, debugging
• Object-Level Authorization: data jurisdiction, permission evaluator, data visibility
• Unit-Testing Backend Authorization

OAuth2

• Tokens, Actors, Front- vs Back- channel, Single-Sign On (SSO)
• Flows: Authorization Code, Client Credentials, Implicit Flow Authorization Code+PKCE
• Social Login (eg “login with Google”), OpenID Connect
• Workshop: Spring OAuth using KeyCloak
• [optional deep-dive] Example attacks on OAuth; dissecting the exchanges (2 hours)

Spring Framework

This course provides a comprehensive, hands-on overview of Spring, covering everything from core concepts like dependency injection and REST APIs to advanced topics like transactions, security, and testing.

Introduction

This course covers key Spring topics, including defining beans, dependency injection, configuration properties, AOP, REST API design, and Spring Boot fundamentals. You'll explore transaction management, multithreading, caching, operations tooling, and Spring Security. Optional modules include OAuth2 with Keycloak, messaging, integration testing, Spring Batch, WebSockets, and Spring Integration. The course wraps up with practical scenario discussions and learning resources.

This course is designed for both entry-level developers new to Spring and experienced developers looking to deepen their hands-on knowledge.

Agenda

Spring Container

• Defining Beans via component-scanning, @Bean and @Import
• Dependency Injection styles, polymorphism, Profiles, @Primary
• [optional] Bean Lifecycle @Scope

Configuration Properties

• @Value, @ConfigurationProperties, configuration sources

Aspect Oriented Programming

• proxy mechanics & pitfalls, writing a custom @Aspect

REST Endpoints:

• API design best practices, validation, documentation, exception handling

Spring Boot:

• library version management, Auto-configuration/ConditionalOn…

Transaction Management

• Database transaction, ACID, Isolation Anomalies
• @Transactional propagation, rollback, read-only tx
• Performance best practices, [after-tx hooks]
• JPA transactional magic: write-behind, flushing, lazy*loading

Multi*threading:

• @Scheduled, Spring thread pools, @Async, and non*blocking REST APIs

Caching:

*annotation and programmatic, design tradeoffs and pitfalls

Ops Features:

• Spring Actuator, Centralized Logging, Metrics & Traces

Spring Security

• Authentication via: login form, basic, api-key, JWT Bearer Token, Preauth Headers,
• Authorization via: URL pattern vs annotations, role vs authority, data-security
• Spring Security Architecture, Custom Security Filters

Spring OAuth2

Messaging

• Listener, Error Handling, Metadata, Spring Cloud Stream (Functional-Style)

Integration Testing - only topics relevant to the team will be covered

• Overriding beans and properties
• Testing DB interaction vs in*memory/Testcontainered DB, data cleanup strategies
• Testing API calls against WireMock
• Testing send/receive (Kafka) messages
• Testing multi*threaded code
• Calling your API with white-box/gray-box/black-box testing, writing testing DSLs, epic tests
• Contract Testing: Contract freeze test, Pact or Spring Cloud Contract
• Exercise: refactoring a mock-full unit test to an end-to-end system test
• Optimizing test execution time: Spring context cache, Slice tests

Spring Batch[optional]:

• Tuning Performance: Chunking, Parallel Steps, Parallel chunks

WebSockets [optional]

Spring Integration (IntegrationFlows DSL) [optional]

Wrap-up: brainstorm on real-life scenarios, best learning sources

Unit Testing

Master modern unit and integration testing techniques to confidently refactor legacy code, write meaningful tests, and navigate complex frameworks with speed and clarity.

Introduction

In this workshop, we’ll tackle key challenges developers face today: how to safely introduce unit tests into legacy code and refactor with confidence, what to do when a growing collection of small unit tests starts slowing down rather than supporting development, and how to write fast, clean integration tests in microservice environments that rely heavily on framework-level abstractions.

The training is designed to empower developers to thoroughly unit-test their code, understand the design feedback that unit tests provide, and review today’s state-of-the-art techniques for both unit and integration testing.

Requirements: Experience in unit testing and comfort with mocking frameworks.

Day 1 ⋅ Fundamentals, TDD, and Testing Techniques

• Testing ROI: Why do we write tests? why early? why test bugs?
• Testing Metrics: Line Coverage, Branch Coverage, Mutation Testing
• Strategies: Test Pyramid vs. Honeycomb Testing
• Test Anatomy: Given/When/Then structure, naming tests (scope vs. specificity), Single Assert Rule
• Test-Driven Development (TDD):
• Red-Green-Refactor flow
• TDD rules, pros, and cons
• TDD Styles: Chicago ("triangulation") vs. London ("outside-in")
• Exercise: Classic TDD Coding Kata + optional Outside-in TDD
• Creating test data
• Expressive asserts with Assert4J (assertThat)
• Parameterized Tests: uses/abuses
• Gherkin Tests (.feature files), BDD
• Testing Legacy Code: Characterization tests and Golden-Master technique
• Approval Testing
• Breaking encapsulation for tests — debate
• Hierarchical test fixtures

Day 2 ⋅ Advanced Mocking, Test-Driven Insights, and Integration Testing

• Mocks: 3 pros, 3 cons
• Basic Features (recap): stubbing, verification, argument matchers, captors, static mocks
• Advanced/Dangerous Features: lenient, any, spy, doReturn, times, noMoreInteractions
• Exercise: Testing Legacy Code
• Social Unit Tests (vs testing boilerplate code)
• Precise method signatures
• Specialized data structures
• Object Mother Pattern (vs mocking getters)
• Agnostic Domain (vs logic mixed with infrastructure)
• Split by Layers of Abstraction (vs partial mocking)
• Split unrelated complexity (vs fixture creep)
• Contract-Driven Testing (Mock Roles, not Objects)
• Extract complexity in Pure Functions
• Integration Testing with Spring
• Code Review of Unit Tests from Participants (optional)