Choose between an enterprise service bus, an integration platform and a message broker based on coupling and latency needs.
Information & Communications Technology
Enterprise Application Integration Using Middleware and Message Queues
Design enterprise integration solutions using middleware, message queues and event-driven patterns that connect applications reliably without tight coupling.
🗓️Duration5 training days
📚Content4 modules · 8 sessions
🎓On completionAccredited attendance certificate
About the programme
Course Overview
Connecting dozens of applications with direct point-to-point calls creates a web of dependencies where a single service outage cascades across the estate and no one can say with confidence what talks to what. Middleware and message queues break that tight coupling by letting applications publish and consume events without knowing about each other directly. This course teaches participants to choose between an enterprise service bus, an integration platform and a message broker based on the coupling, latency and ordering requirements of each integration. Participants design event schemas with a versioning strategy, apply the transactional outbox pattern to keep database writes and message publishing consistent, and implement idempotent consumers that tolerate duplicate delivery without corrupting data. Sessions cover dead-letter queue handling for messages that repeatedly fail processing, the saga pattern for coordinating a distributed transaction across services, and contract testing that catches breaking schema changes before they reach production. A case exercise works through integrating an order system with fulfilment and billing services using an event-driven design, including failure handling when billing is temporarily unavailable. By the end, participants can design an integration architecture and build in the resilience an enterprise integration needs.
Expected Learning Outcomes
Design event schemas with a versioning strategy that lets producers and consumers evolve independently.
Apply the transactional outbox pattern to keep database writes and message publishing consistent.
Implement idempotent message consumers that tolerate duplicate delivery without corrupting downstream data.
Design dead-letter queue handling and retry policies for messages that repeatedly fail processing.
Apply the saga pattern to coordinate a distributed transaction across services without a shared database.
Set up contract testing between producer and consumer services to catch breaking schema changes before deployment.
Who Should Attend
Integration architects designing middleware and messaging solutions across an application estate.
Backend developers building event-driven services that publish or consume messages.
Solution architects evaluating enterprise service bus or integration platform options.
API and platform engineers responsible for message broker infrastructure.
Technical leads coordinating integration design across multiple development teams.
Quality engineers building contract and integration test suites for messaging systems.
Course Modules
Select any module to see its sessions and points.
01Integration Architecture Choices
2 sessions · 8 points
Session 1Coupling, Patterns and Platform Selection
- Compare point-to-point, publish-subscribe and request-reply integration patterns against latency and coupling requirements.
- Evaluate an enterprise service bus against an integration platform and a lightweight message broker for a given scenario.
- Map existing point-to-point integrations to identify candidates for migration to an event-driven design.
- Assess ordering, delivery guarantee and throughput requirements before selecting a messaging technology.
Session 2Designing Event Schemas
- Design event schemas in a format that supports backward-compatible evolution as producers change over time.
- Define a schema versioning strategy that lets producers and consumers upgrade independently without coordinated releases.
- Separate event payload design from transport concerns so the same schema can move across different brokers if needed.
- Register schemas in a shared registry so consuming teams can discover and validate against them before integrating.
02Reliable Message Processing
2 sessions · 8 points
Session 1Consistency Between Data and Messaging
- Apply the transactional outbox pattern to guarantee a database write and its corresponding event are never split.
- Compare outbox-based publishing against two-phase commit and change data capture approaches for consistency needs.
- Design consumer logic that processes events exactly once in effect, even when the broker delivers duplicates.
- Test failure scenarios where a consumer crashes mid-processing to confirm no message is silently lost.
Session 2Handling Failures and Dead Letters
- Design retry policies with backoff for transient failures before a message is routed to a dead-letter queue.
- Build dead-letter queue monitoring and replay tooling so failed messages can be inspected and reprocessed safely.
- Distinguish poison messages caused by malformed data from failures caused by a temporarily unavailable consumer.
- Set alerting thresholds on dead-letter queue depth so persistent failures are caught before they accumulate unnoticed.
03Coordinating Distributed Transactions
2 sessions · 8 points
Session 1The Saga Pattern
- Apply the choreography-based saga pattern to coordinate a multi-step transaction using events alone.
- Apply the orchestration-based saga pattern when a central coordinator needs to track transaction state explicitly.
- Design compensating transactions that reverse completed steps when a later step in a saga fails.
- Choose between choreography and orchestration based on the number of participants and visibility requirements.
Session 2Testing Distributed Workflows
- Design integration tests that exercise a saga across multiple services using test doubles for external dependencies.
- Simulate partial failure scenarios to confirm compensating transactions restore a consistent business state.
- Trace a saga's execution across services using correlation identifiers carried through every event.
- Document saga state machines so operations staff can diagnose a stuck transaction without reading source code.
04Governance and Quality Assurance
2 sessions · 8 points
Session 1Contract Testing Between Services
- Set up consumer-driven contract tests that fail a producer's build when it breaks an agreed message schema.
- Run contract verification in continuous integration pipelines before a producer or consumer service is deployed.
- Manage contract test suites across teams so ownership of each contract is clear as services evolve.
- Use contract test failures to trigger a conversation between teams before a breaking change reaches production.
Session 2Operating the Integration Estate
- Monitor message broker throughput, consumer lag and queue depth to catch integration bottlenecks early.
- Maintain a catalogue of event types, producers and consumers so integration dependencies remain visible.
- Plan capacity for message brokers ahead of anticipated growth in event volume across the estate.
- Review and retire unused integration flows to keep the middleware estate maintainable over time.
What the participant receives
4 course modules
A structured syllabus
8 training sessions
across 5 days
32 detailed points
Applied, detailed content
Accredited attendance certificate
On completing the programme
Complete your registration
We will contact you within one business day to confirm.
Ready to start?
Reserve your seat and start building the skill.