🎓 Training Center

A microservices-based educational platform demonstrating DDD and modern software architecture

📊 Quality & CI/CD Status

Microservice	Quality Gate	Coverage	Bugs	Code Smells
Discount Management
Open Trainings
Payment Gateway
Personal Data
Reviews
Trainings Catalogue
Training Offer
Training Programs

🎯 Project Goal

This repository demonstrates how to build and maintain a modern microservices architecture following best practices and industry-standard patterns:

• Microservices Architecture - Decomposing a complex domain into manageable, independently deployable services
• Event Storming - Collaborative domain exploration technique to identify bounded contexts
• Port and Adapters Architecture (Hexagonal) - Separation of business logic from external concerns
• Domain-Driven Design - Designing software to reflect the business domain and ubiquitous language

📑 Table of Contents

This documentation provides insights into the tools, techniques, and decisions made throughout the project:

1. Getting Started - Setup and installation instructions
2. Technology Stack - Core technologies used in the project
3. Project Artifacts - Event storming outputs and architecture decisions
4. Business Overview - Domain understanding and requirements
   1. Brief Description
   2. High-level Requirements
5. Educational Resources
   1. Articles - Blog posts explaining project evolution
   2. Books Worth Reading
   3. External Resources
6. Contributing - Guidelines for contributors

🚀 Getting Started

Prerequisites

• Java 21
• Docker and Docker Compose
• Maven

Installation

1. Clone the repository:

   git clone https://github.com/smalaca/training-center-microservices.git
   cd training-center-microservices

2. Build the project:

   ./mvnw clean install

3. Start the infrastructure services:

   docker-compose up -d

4. Start each microservice:

   ./mvnw spring-boot:run -pl open-trainings
   ./mvnw spring-boot:run -pl payment-gateway
   ./mvnw spring-boot:run -pl personal-data-management
   ./mvnw spring-boot:run -pl discount-management
   ./mvnw spring-boot:run -pl training-offer
   ./mvnw spring-boot:run -pl training-programs
   ./mvnw spring-boot:run -pl reviews
   ./mvnw spring-boot:run -pl trainings-catalogue

🛠️ Technology Stack

• Java 21 - Core programming language
• Spring Boot - Application framework
• Spring Data JPA - Data access
• Kafka - Event streaming
• Docker - Containerization

📦 Modules

• annotations - Java annotations for marking architectural patterns like CQRS and Ports and Adapters, as well as domain-driven design concepts
• annotations-test - Annotations for categorizing and organizing tests, particularly in a JUnit and Spring Boot context
• schema-registry - Classes for managing metadata and schemas in an event-driven architecture
• discount-management - Responsible for managing discount codes for training offers
• open-trainings - Responsible for managing open training sessions, including registration, booking, and order processing
• payment-gateway - Responsible for processing payments for training purchases
• personal-data-management - Responsible for managing personal data of users, trainers, and participants
• training-offer - Responsible for managing training offers, including pricing and availability
• training-programs - Responsible for managing training programs
• reviews - Responsible for reviewing training programs
• trainings-catalogue - Responsible for viewing training programs and training offers

📋 Project Artifacts

Event Storming

All event storming sessions are documented in our Miro Board, which includes:

• Big Picture Event Storming - Holistic view of the domain
• Bounded Contexts - Service boundary identification
• Core/Supporting/Generic Domains - Domain categorization
• Process Level Event Storming - Detailed workflow mapping

Architecture Decisions

We document significant architectural decisions in our Architecture Decision Records (ADRs) to provide context for future development.

🏢 Business Overview

Brief Description

The Training Center is an institution that provides structured training and education in various professional fields, connecting qualified trainers with individuals and organizations seeking to develop their skills.

High-level Requirements

📚 Trainings Management

Management of training programs that are ready for delivery or in preparation:

• Discoverability: Allow potential participants to browse available trainings
• Administration: Support for creating and modifying training content
• Supervision: Each training program has designated supervisors

📣 Marketing & Advertisement

Activities designed to attract potential attendees:

• Webinars: Free introductory sessions on relevant topics
• Conference Presentations: Professional talks at industry events
• Internal Events: Knowledge-sharing sessions within organizations

👨‍🏫 Trainer Management

System for managing relationships with training professionals:

• Expertise Tracking: Record of which trainings each trainer can conduct
• Skills Database: Comprehensive skills inventory for each trainer
• Financial Management: Tracking of trainer rates and payments
• Performance History: Record of past trainings with participant feedback
• Contractual Management: Handling trainer agreements and terms

🌐 Open Trainings

Public training sessions open to individual registration:

• Scheduling: Management of training dates and times
• Payment Processing: Handling of participant payments
• Cancellation Handling: Process for participant resignations
• Trainer Agreements: Management of contracts with training providers
• Capacity Planning: Enforcement of minimum/maximum group sizes
• Cancellation Policies: Rules for training cancellations

🏭 Dedicated Trainings

Custom training programs for corporate clients:

• Customization: Ability to adjust training content to company needs
• Client Communication: Interface for discussions with company representatives
• Confidentiality: Management of Non-Disclosure Agreements

📚 Educational Resources

The following resources explain the evolution of this project and the reasoning behind key decisions:

Examples

Category	Pattern/Concept	Miro Board	Code Example
🎯 Event Storming	Big Picture	View	-
	Process Level	View	-
	Design Level	View	-
🏗️ DDD Strategic	Domain Types	View	-
	Bounded Contexts	View	-
🏗️ DDD Tactical	Aggregate	View	Offer Aggregate
	Entity	-	Participants
	Value Object	-	OfferNumber
	Repository	-	OfferRepository
	Factory	-	OfferFactory
	Domain Event	-	Offer Events
	Domain Service	-	TrainingOfferDomainService
	Policy	-	ReviewerAssignmentPolicy
	Specification	-	TrainingProgramProposalReviewSpecification
	Saga (Choreography)	-	Training Program Events
	Saga (Orchestration)	View	OfferAcceptanceSaga
🏛️ Architecture	Architecture Decision Record	-	ADR Records
	Architecture Tests	-	ArchUnit
	Event-Driven	-	Training Program Events
	Ports & Adapters	-	Open Trainings Module
	Outbox Pattern	-	JpaOutboxMessageRepository
	Event Sourcing	-	OfferAcceptanceSaga
	CQRS (Within Service)	-	Application vs Query
	CQRS (Between Services)	-	Commands: training-programs, training-offer / Query: trainings-catalogue
🧪 Testing	Unit Tests	-	OfferApplicationServiceTest
	Integration Tests	-	JpaOfferRepositoryIntegrationTest
	System Tests	-	OfferRestControllerSystemTest
🔄 CI/CD	CI Pipeline	-	GitHub Actions
	Code Quality	-	SonarCloud Analysis

Articles

A chronological series of blog posts documenting the project journey. If you want you can also explore my blog Mind The Architecture.

1. Event Storming Foundations
   1. Event Storming Foundations: Understanding events as immutable business facts (Part 1)
   2. Event Storming Foundations: Preparing for a successful workshop (Part 2)
   3. Event Storming Foundations: Choosing your workshop type (Part 3)
   4. Event Storming Foundations: Facilitating beyond the basics (Part 4)
2. Event Storming Big Picture
   1. Event Storming Big Picture: The big picture workshop explained (Part 1)
   2. Event Storming Big Picture: Exploring the chaos (Part 2)
   3. Event Storming Big Picture: Enforcing the timeline (Part 3)
   4. Event Storming Big Picture: Choosing the first event (Part 4)
   5. Event Storming Big Picture: Keeping the workshop on track (Part 5)
   6. Event Storming Big Picture: Turning insights into action (Part 6)
3. Software Architecture Introduction
   1. The good, the bad and the boundaries
   2. Mind the gap between problem and solution spaces
4. Domain-Driven Design Introduction
   1. The strategic and tactical sides of Domain-Driven Design
5. Strategic Domain-Driven Design: Ubiquitous Language
   1. Ubiquitous Language: Stopping the translation game (Part 1)
   2. Ubiquitous Language: Words that reveal domains (Part 2)
   3. Ubiquitous Language: Structuring knowledge into domains (Part 3)
6. Strategic Domain-Driven Design: Domain Types
   1. Domain Types: Identifying core, supporting, and generic domains (Part 1)
   2. Domain Types: Build, buy, or outsource? (Part 2)
   3. Domain Types: What if you build nothing? (Part 3)
   4. Domain Types: The architecture your subdomain deserves (Part 4)
   5. Domain Types: Ownership is not random (Part 5)
   6. Domain Types: How much should you trust AI? (Part 6)
   7. Domain Types: Three Myths About Domain Types (Part 7)
7. ... TBD

Books worth reading

• Domain-Driven Design
  • Domain-Driven Design Distilled by Vaughn Vernon
  • Implementing Domain-Driven Design by Vaughn Vernon
  • Learning Domain-Driven Design by Vlad Khononov
• Event Storming
  • Introducing EventStorming by Alberto Brandolini
• Microservices
  • Building Microservices by Sam Newman
  • Microservices Patterns by Chris Richardson
  • Monolith to Microservices by Sam Newman
  • Production-Ready Microservices by Susan J. Fowler
  • Strategic Monoliths and Microservices: Driving Innovation Using Purposeful Architecture by Vaughn Vernon, Tomasz Jaskula
• Software Architecture
  • Architecture for Flow: Adaptive Systems with Domain-Driven Design, Wardley Mapping, and Team Topologies by Susanne Kaiser
  • Balancing Coupling in Software Design by Vlad Khononov
  • Building Evolutionary Architectures by Neal Ford, Rebecca Parsons, Patrick Kua, Pramod Sadalage
  • Clean Architecture by Robert C. Martin
  • Designing Data-Intensive Applications by Martin Kleppmann
  • Event Processing. Designing IT Systems for Agile Companies by K. Chandy, W. Roy Schulte
  • Software Architecture: The Hard Parts by Neal Ford, Mark Richards, Pramod Sadalage, Zhamak Dehghani
  • The Software Architect Elevator by Gregor Hohpe
• Software Development
  • Growing Object-Oriented Software, Guided by Tests by Steve Freeman, Nat Pryce
  • Release It! by Michael T. Nygard
  • The Phoenix Project by Gene Kim, Kevin Behr, George Spafford
• Testing
  • Developer Testing: Building Quality into Software by Alexander Tarlinder

External Resources

• Architecture Decision Record
  • Architecture decision record (ADR) by Joel Parker Henderson
• Event Storming
  • Awesome EventStorming by Mariusz Gil
  • Introducing Event Storming by Alberto Brandolini
• Testing
  • ArchUnit

🤝 Contributing

Contributions are welcome! Here's how you can help improve this project:

Development Process

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Guidelines

• Follow the existing code style and architectural patterns
• Write tests for new features
• Update documentation as needed
• Adhere to DDD principles when implementing domain logic

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.