For a small application, the speed of development typically outweighs the design concerns. Getting your code to production as fast as possible becomes your first goal. And nothing is faster than building a (messy) monolith. However, not many months of development later, or when the team grows bigger, you need to change your attitude. Keeping the design clean becomes crucial to the long-term survival of your project in the ever-changing environment of today. 

This training covers the most important architectural concepts and principles underlying the most widely used architectures today, that every developer should be familiar with before implementing any production code. Inspired by the Domain-Driven Design (DDD) movement and Adam Bien's book Rethinking Java EE Patterns, the course introduces a strategy for evolutionary architectures, allowing you to expand the design to accommodate growing complexity in the requirements.

This is the recording of a 3.5 hours live webinar that took place in June 2021.

Note: After watching the recording you can ask me any question you have via email.


  • Adapter Design Pattern and the Anti-Corruption Layer (DDD)
  • Dependency Inversion Principle - stop external systems from polluting our Domain
  • Facade Design Pattern and the Application Service (DDD)
  • Layered Architecture and Relaxed- variant
  • “Light-CQRS” - Separate Read/Write Models in a pragmatic way
  • Repository Pattern - when to design a separate Persistence Model?
  • Data Transfer Objects (DTOs) - why/when to keep them out of our Domain
  • The Universal Architecture (aka Clean-, aka Hexagonal-, aka Ports-and-Adapters, aka Onion-) 
  • A pragmatic approach to evolving the architecture to cope with increasing complexity
  • Breaking down a monolith into independent verticals - an incremental technique
  • Stages of decoupling: data links, inter-domain calls, and events, transactions, database links and replication, cross-domain queries, microservices.
  • Applying incremental constraints to the architecture

What to expect?

The course is mainly composed of debates about architecture styles, design concerns, pitfalls, and tradeoffs. To demonstrate some of the incremental decoupling techniques, we often jump to code to experiment with the ideas (30-50% of the time). Along the lines, you'll also learn a number of pragmatic coding tricks you should have in your toolbox, some related to Spring Framework, but most - framework-agnostic.

After following this course you’ll acquire a solid knowledge of the core design principles, applied to a range of scenarios. You’ll be able to understand “the why” behind your current architecture or perhaps challenge the status-quo to further simplify your code. Of course, any questions you might have after watching the recording are warmly welcome.

After the purchase you will get: the video recording, all the slides, and the code zipped together with Git commit history.

This Training is for you because:

  • You want to rethink your current project architecture - migrating to microservices, modularizing the codebase, or just cleaning it up
  • You are about to start a new project (or recently started) and you want to make sure you are on the right track
  • You simply want to know more about software architectures, and how you can make the best design decisions tomorrow


  • Some prior contact with design decisions/architectures is recommended, or
  • Enthusiasm about software design.

Technical Requirements

I would recommend you get yourself a black coffee and pay close attention to the discussion, stop the recording at any moment, debate the ideas with your colleagues and perhaps try to reproduce my coding on your own machine. In the resources section, you can find the code zipped together with the git history, so you can explore my commits if you get lost. If still can't make it work, please don't hesitate to email me!

To run the project you will need a Java 8+ SDK installed, a decent IDE, and access to GitHub and Maven Central.

Course Curriculum

Available in days
days after you enroll

Trainer: Victor Rentea

Victor Rentea is a Java Champion, Associate Professor and Technical Trainer writing code for over two decades in many languages.

He is training developers since 2012, having developed an extensive curriculum that covers most of the software engineering best practices and typical Java-stack development. By now he trained over 2000 developers in 40+ companies, and you can read dozens of their recommendations on LinkedInFacebook, and on

Victor is best known for the energy of his talks, many ranked among the best 3 at their conference. You can expect a similar style for any training he gives while explaining complex concepts in simple, easy to remember terms. If you want to keep close, you can join the Software Craftsmanship Community he founded in Romania or follow him on LinkedIN, Twitter, or Facebook.

Get Access

Frequently Asked Questions

Can I get an invoice for my company (VAT-free)?

To add the VAT code of your company to the checkout page and remove the VAT taxes, follow these simple steps.

Can I ask questions after I watch the recording?

PLEASE DO! Email me your questions, no matter how silly or complex you may think they are. I'd be glad to help, so don't hesitate to contact me.

How long do I have access to the course?

How does lifetime access sound? After enrolling, you have unlimited access to this course for as long as you like - across any and all devices you own.

What if I am unhappy with the course?

We would never want you to be unhappy! If you are unsatisfied with your purchase, contact us in the first 30 days and we will give you a full refund.

Can I have this training for more of my colleagues?

There are two ways I can help you:

  • For 5+ developers, contact me for a discount and a company invoice
  • For 10+ developers or for a longer in-depth session, contact me for a dedicated webinar for your company.