### Abstract

Reading about integration patterns is easy. Knowing which one to reach for when a partner's feed arrives malformed at 3am is a different skill, and it is only learned by building something and then breaking it.

In this workshop you will build a working integration pipeline for a shipping domain. Bookings arrive from two partners in two formats over two transports. You will normalize them, split a batch into individual bookings, enrich each one against a reference service, route by content, and publish downstream — and then we will start injecting failures. Duplicate deliveries, a poison message, a downstream service that goes away mid-transaction. Each failure introduces the pattern that handles it.

**What we'll do:**

- Build a Camel route from scratch and grow it into a content-based router
- Split an inbound batch, enrich each element, and aggregate the results back together
- Make the pipeline idempotent so a partner's duplicate delivery stops corrupting downstream state
- Add a dead letter channel and watch a poison message stop taking the route down with it
- Implement a saga that compensates a booking when a downstream service fails halfway
- Trace a single message across the whole pipeline in Grafana

**Workshop Structure:**

- Setup and orientation to the scenario (15 min)
- First routes: from, to, and content-based routing (20 min)
- Splitter, content enricher, and aggregator over a booking batch (30 min)
- Injecting failure: idempotent consumer, dead letter channel, retry with backoff (25 min)
- Saga: compensating a partially completed booking across two services (20 min)
- Debrief and building the pattern decision map (10 min)

**Technical Details:**
Participants work singly or in pairs in Java with Quarkus and the Camel extensions. A `podman compose` stack provides everything else — Kafka, Postgres, an FTP endpoint, and a Grafana LGTM stack for tracing — so nothing needs installing beyond Podman, a JDK, and Git. Starter code is in a public repository with setup instructions and a working baseline, so no one spends the first half hour fighting a build. Each exercise has a completed branch to fall back on.

### Level of Expertise

Intermediate — comfortable writing Java. No Camel or messaging background required; the patterns are introduced as the failures that motivate them appear.

### Target Audience

Developers and architects who build or maintain integrations. Especially suited to teams about to replace a hand-rolled integration layer, and to anyone who has been told to "just add a retry."

Requirements:

Laptop
Browser
Github account
Basic Java skills