Scala Advanced Developer

You will learn how to think and design in a purely functional style using Scala 3. Starting from algebraic data types and pattern matching, you will build up to advanced type classes, monadic composition, and higher-kinded types — giving you the tools to write code where each function can be understood in isolation and composed with others without surprises.

Get to know how Cats Effect transforms the way you handle side effects, concurrency, and resource management. You will learn to write programs using the IO monad, leverage fiber-based concurrency for massive parallelism, and use primitives like Ref, Deferred, and Queue to coordinate concurrent workflows — all without the pitfalls of traditional thread-based programming. Because IO is referentially transparent, every expression can be reasoned about locally — making concurrent code as understandable as sequential code.

You will master streaming data processing with FS2 and Pekko Streams, understanding when to reach for each. From pull-based lazy pipelines to backpressured reactive streams, you will learn to build robust data processing systems that handle real-world workloads. Pipes and stream operators compose just like functions, letting you build complex processing pipelines from small, testable, reusable stages.

The training covers event sourcing and CQRS with Pekko Persistence, teaching you how to model domain entities as event-sourced actors, implement command and event handlers, and build read-side projections. You will also learn how to extract pure domain logic from infrastructure — keeping command handlers small, locally testable, and composable as the system grows.

Finally, you will integrate all of these tools into a layered, production-grade architecture — covering testing strategies, configuration management, dependency injection, observability, and deployment. Tagless final and Resource give you composable application layers where each component can be understood in isolation. The capstone project gives you the opportunity to apply everything you have learned to a real problem. In an era where AI generates ever more code, these skills shift from writing code to confidently reviewing and verifying it — local reasoning and strong types make AI-generated code safe to trust.

This training is for every developer or architect who wants to:

Master local reasoning and composition as foundational principles — from pure functions to full system architecture — so your code is readable, testable, and maintainable by default.

From type classes to concurrent streaming to event sourcing — Cats, Cats Effect, FS2, and Pekko covered end-to-end in a single, structured training.

Apply everything you have learned to a real problem and walk away with a portfolio-ready project demonstrating production-grade functional Scala.

AI shifts the bottleneck from writing code to reviewing and verifying it. Local reasoning, composition, and a strong type system make AI-generated code reviewable and safe — the compiler catches what a human skimming AI output would miss.

Worried functional programming is too academic? Every concept earns its place by solving a real problem — no category theory for its own sake. You learn just enough theory to apply it pragmatically, then put it to work on production concerns like testing, configuration, observability, and deployment.

Taught by a trainer with more than a decade building extensive, production JVM backend systems and certified in Training from the Back of the Room — you learn battle-tested patterns from someone who has shipped them.

The training is structured as three intensive days using Training from the Back of the Room (TBR) techniques. Every session combines interactive lections with REPL-driven live coding, hands-on exercises, and quiz sections. Each day builds on the previous one, so attending all three days is important for getting the most out of the program.