Trainers
Difficulty
- Beginner
Dauer und Teilnehmerzahl
- 3 days (9:00 a.m. – 4:00 p.m.)
- Maximal 12
Language
- German
- English
Pricing
-
Private training: €2,500 per day plus travel expenses
- Open Training: €1,000 per participant
CIB seven Developer Training
Hands-on training for Java developers and software architects
CIB seven Developer Training is designed for Java developers and software architects who want to gain their first hands-on experience with CIB seven and accelerate their automation projects in a structured manner.
Over the course of three training days, participants will learn how to model executable BPMN processes, seamlessly integrate process logic into Java, implement user tasks, manage transactions and error handling, test processes, and address key architectural and operational issues.
Participants should be familiar with Java, dependency injection, and unit testing. They should be comfortable using their IDE and have access to a working development environment during the training.
Fundamentals, Platform, Initial Implementation
1. Kickoff and Training Setup
- Goals, Expectations and Procedure
- Setting up the toolchain: IDE, build, runtime, deployment model
2. Fundamentals of Process Modeling with BPMN 2.0
- Key Elements and Best Practices for Executable Models
- Modeling Guidelines: Comprehensibility, Maintainability, Error Prevention
- Common Anti-Patterns from Real-World Practice
3. Insights into the CIB seven Platform
- Component Overview: Engine, Modeler, Tasklist, Admin Functions
- Deployment Concepts and Runtime Artifacts
- Einordnung für Teams mit Camunda-7-Erfahrung: Gemeinsamkeiten, Unterschiede und Migrationsaspekt
4. CIB seven APIs and Code Delegation
- Java Delegates, Execution Listener, Task Listener
- Variable Access and Scope
- Error Handling and Technical vs. Business Exceptions
- Exercise: Service Task Implementation with a Clean Interface
5. Data Objects, Gateways, and Expressions in the Process
- Data Objects and Variable Modeling
- Gateways: XOR, AND, event-based, common pitfalls
- Expressions: Conditions, mappings, simple calculations
- Exercise: Process with routing logic and expressions
User tasks, transactions, architecture, tests, external tasks
6. Handling user tasks in the process
- Lifecycle of User Tasks, Assignment, Candidate Groups
- Forms and Variable Mapping
- Task Completion, Validation, Business Keys
- Exercise: End-to-End Flow with User Tasks and Form Data
7. Transaction Processing in CIB seven
- ACID Basics in the Context of the Engine
- Async Continuations, Job Executor, Retries
- Systematically Analyzing Incidents and Error Scenarios
- Exercise: Triggering Errors, Optimizing Retries, Analyzing Incidents
8. Insights into the Architecture of Process Applications
- Architectural styles and patterns for process applications
- Modeling Integrations: Delegates vs. External Tasks
- Monitoring and Observability: Logging, Metrics, Tracing
9. Performing Process Tests
- Unit Tests for Delegates and Listeners
- Engine Tests for BPMN Paths and Variable Mapping
- Mocking Integrations, Test Data Strategy
- Exercise: Implement a worker and account for common error cases
10. External Task Patterns in CIB seven
- Pull model, topics, locking, retries, error handling
- Idempotence, exactly-once, correlation IDs
- When external tasks are better than delegates
- Exercise: Implementing workers, handling typical error cases
Events, DMN, Enterprise Topics, Wrap-up
11. Event Handling
- Messages, Timers, Signals, Error Events
- Boundary Events, Event Subprocesses, Escalation Patterns
- Correlation and Design of Message Payloads
- Exercise: Timeouts and Fallback Paths with Events
12. Automating Business Rules with DMN
- DMN Fundamentals: Decision Tables, Hit Policies
- Versioning, Testability, Responsibility for Business Rules – Between Business Units and IT
- Integration into Processes and Variable Mapping
- Exercise: Integrating a DMN Decision into a Process and Testing It
13. CIB Seven for Businesses
- Governance: Model Standards, Review Processes, Reusability
- Operations: Deployment Strategies, Rollback, Migration, Process Monitoring
- Overview of the product portfolio, typical enterprise use cases
- Introduction to CIB flow and easyForms
- Introduction to coSys and document workflows
14. Outlook, Feedback, and Q&A Session
- Summary of best practices as a checklist
- Typical next steps in the project: Starter template, architecture blueprint
- Q&A, feedback, wrap-up
Eligibility Requirements
For the developer training, participants need a solid understanding of Java and basic experience with typical backend topics. Ideally, they should be able to build and run a Spring Boot project, be familiar with Maven or Gradle, be comfortable working with Git, and have a basic understanding of REST APIs, JSON, XML, and data modeling.
Basic knowledge of transactions, logging, and error handling is also helpful, as is an understanding of asynchronous processing and messaging. Prior experience with BPMN or Camunda 7 is not required, but it will help you get up to speed more quickly.
For the hands-on exercises, all participants will need a local development environment set up with the JDK, an IDE, and Git, as well as access to the provided sample project or repository.
Overview of requirements:
- Java skills
- Experience with dependency injection and unit testing
- Proficiency in using IDE, Maven/Gradle, and Git
- Basic knowledge of REST, JSON, XML, and data modeling
- Access to a local development environment with the JDK and a sample project or repository
Helpful: Experience with BPMN or Camunda 7
Learning Objectives
After completing the training, participants will be able to apply key concepts of CIB seven and implement typical process automation projects in a structured manner. They will learn how to design executable BPMN models, evaluate them from both a business and technical perspective, and seamlessly integrate process logic into Java.
In addition, they can make targeted use of variables, gateways, expressions, user tasks, events, and integration patterns. They learn how to design transaction boundaries, asynchronous operations, retries, and error handling in a way that ensures process instances run more robustly and incidents can be analyzed in a structured manner.
Participants will also gain an overview of how process applications can be architecturally designed, tested, operated, and further developed as a team using common standards.
Lernziele im Überblick:
- Evaluate and create BPMN models from both a business and technical perspective
- Seamlessly integrate process logic into Java
- Use variables, gateways, expressions, and events effectively
- Apply patterns for user tasks, integrations, and automation logic
- Design transaction boundaries, asynchrony, retries, and error handling securely
- Ensure stable process operations; detect, analyze, and resolve incidents early and in a structured manner
- Select and implement architecture for process applications
- Automate process tests and establish delivery standards
- Ensure efficient, maintainable, and extensible process automation
Duration and Structure
- The training lasts 3 days, each day from 9:00 a.m. to 4:00 p.m. (6 hours of instruction).
- Take breaks as needed. On average, we allow for a one-hour lunch break.
Organizational Matters
- We offer the training in either German or English.
- The training usually takes place at your location. Upon request, the training can be held in Augsburg at Miragon.