Architecture Pattern Guide

Workflow, Messaging, and Enterprise Integration Patterns

What This Chapter Is About

Help readers choose between APIs, commands, events, streams, workflows, files, and synchronization by starting with communication meaning, business ownership, reliability, partner boundaries, schema evolution, security, audit, and operations.

This chapter builds on microservices and event-driven architecture. Once systems are separated, integration patterns decide how work, facts, records, and processes move across service, team, partner, SaaS, and enterprise boundaries.

Keep one durable idea in view:

Integration architecture starts by naming the communication meaning before choosing a mechanism.

Sections

  1. Commands, Events, Streams, Workflows, and Files

  2. Durable Workflow and Compensation

  3. Partner Boundaries, Schema Evolution, Throttling, and Replay

  4. Integration Security, Audit, and Operating Model

  5. Integration Pattern Provider Lens Notes

How the Chapter Develops

The chapter develops in this order:

  1. Start with communication meaning: API, command, event, stream, workflow, file, or synchronization.

  2. Explain durable workflow, compensation, visible state, retries, and human intervention.

  3. Explain partner boundaries, schema evolution, throttling, replay, and failure semantics.

  4. Add security, audit, observability, operating ownership, and cost.

  5. End with provider lens notes that translate the pattern into Azure and future AWS examples after the integration model is clear.

What You Will Be Able to Do

By the end of this chapter, the reader should be able to:

  • Choose communication patterns by meaning.

  • Explain durable workflow, compensation, and exception handling.

  • Discuss partner boundaries, throttling, schema evolution, replay, and failure semantics.

  • Design security, audit, observability, and ownership for enterprise integration.

  • Add provider lenses without reducing integration architecture to a service catalog.

Key Ideas

  • APIs, commands, events, streams, workflows, files, and synchronization solve different problems.

  • Durable workflow makes long-running process state visible.

  • Compensation and reconciliation matter when one distributed transaction is not realistic.

  • Partner and enterprise boundaries need throttling, schema evolution, replay, audit, and support ownership.

  • Integration architecture protects core systems while allowing business processes to cross boundaries.