Designing an Azure Integration Decision Matrix: Choosing the Right Integration Pattern

{tocify} $title={Table of Contents}


In enterprise integration, selecting the right technology is not always the most difficult part. The real challenge is choosing the right integration pattern for a particular business requirement.

If you have worked on enterprise integration projects, you probably know how quickly an integration landscape can become complicated.

A new business requirement comes in. One team develops an Azure Function, another creates a Logic App, and someone else exposes an API through Azure API Management. Before long, multiple applications are communicating with each other through different integration mechanisms.

Initially, everything works as expected. Teams deliver their requirements, applications exchange information, and business processes continue to run.

However, as the number of integrations increases, managing the overall landscape becomes more challenging.

Consider a typical enterprise environment:

  • An ERP system communicates directly with an e-commerce application.
  • The same ERP system sends order information to a warehouse application.
  • A separate Logic App handles customer notifications.
  • Another application independently retrieves customer information through an API.
  • Each integration has its own retry mechanism, logging approach, and error-handling strategy.

Now imagine the ERP system becomes unavailable. Which integrations will fail? Where will the messages accumulate? Which team is responsible for resolving the issue? How do we identify whether a transaction has already been processed?

These are not simply development problems. They are architectural challenges.

Azure provides several services for building enterprise integration solutions. However, having multiple services available does not automatically mean that we are choosing the right architecture.

What we need is a consistent decision-making approach.

In this article, we will explore how to design an Azure Integration Decision Matrix that helps architects, developers, and technical leads select the appropriate integration patterns while avoiding unnecessary architectural complexity.

1. Understanding Integration Sprawl

Integration sprawl occurs when applications and systems are connected without a consistent architectural approach.

It usually happens gradually. Individual teams solve their immediate requirements, but the overall integration landscape does not receive enough attention.

Azure provides several services for building integration solutions:

  • Azure API Management
  • Azure Logic Apps
  • Azure Service Bus
  • Azure Event Grid
  • Azure Event Hubs
  • Azure Functions
  • Azure Data Factory

Each service addresses a different requirement. Problems arise when teams select services based on familiarity rather than workload characteristics.

For example, using an HTTP-triggered Azure Function for every integration requirement might seem convenient. However, it may not be the right choice when the business process requires durable messaging, message ordering, retry management, or independent consumer processing.

Similarly, using Logic Apps for every workflow can introduce unnecessary orchestration and operational overhead when a simple event notification or API interaction would be sufficient.

Some common symptoms of integration sprawl include:

1. Point-to-point dependencies

Applications communicate directly with multiple downstream systems. Changes in one application can affect several other applications.

2. Inconsistent error handling

Different teams implement their own retry mechanisms, exception handling, and logging strategies.

3. Duplicate integration logic

The same transformation, validation, and business rules are implemented in multiple places.

4. Poor visibility

There is no consistent way to trace a business transaction across APIs, workflows, queues, and backend applications.

5. Increasing operational costs

Unnecessary polling, repeated processing, excessive workflow executions, and poorly configured resources increase costs.

The objective is not to eliminate every point-to-point integration. The objective is to identify where direct communication is appropriate and where decoupling provides a clear architectural benefit.

2. Understanding Requirements Before Selecting an Azure Service

Before choosing an Azure service, I recommend evaluating the integration requirement against the following parameters.

ParameterQuestions to Consider
Communication patternIs it synchronous, asynchronous, event-driven, or batch-based?
LatencyDoes the business require an immediate response, or can processing happen later?
Message volumeAre we processing individual transactions or millions of events?
Payload sizeAre messages small JSON documents, XML files, or large datasets?
OrderingMust messages be processed in a particular sequence?
Delivery requirementsIs at-least-once delivery sufficient? What happens if a message is delivered twice?
State managementDoes the integration require a long-running business process?
TransformationIs simple mapping sufficient, or do we need complex XML, JSON, EDI, or flat-file processing?
SecurityAre authentication, authorization, private connectivity, or partner security requirements involved?
OperationsHow will we monitor, retry, troubleshoot, and recover failed transactions?
CostWhat are the expected execution, messaging, storage, and compute costs?

These questions help us understand the actual workload instead of starting with a technology preference.

For example, consider two requirements:

Requirement A: An e-commerce application needs an immediate response when requesting the current inventory quantity.

Requirement B: An ERP system needs to notify multiple downstream applications whenever an order is created.

Both involve exchanging information, but their integration patterns are different.

Requirement A is generally a synchronous request/reply scenario.

Requirement B is better suited to an asynchronous messaging or event-driven approach.

This distinction is the starting point for an effective integration architecture.

3. The Azure Integration Decision Matrix

The following matrix can serve as a baseline for architecture reviews and technical design discussions.

Integration RequirementRecommended Azure ServicesWhen to UseImportant Considerations
Synchronous request/replyAPI Management + Azure Functions or backend APIReal-time application requests, partner APIs, and immediate responsesBackend availability, throttling, timeout behavior, and API security
Stateful business orchestrationAzure Logic Apps StandardMulti-step workflows, ERP integration, B2B processes, and connector-based integrationsWorkflow state, execution history, connector limitations, and hosting model
Reliable asynchronous messagingAzure Service BusBusiness commands, order processing, and decoupled application communicationSessions, duplicate detection, dead-letter queues, and idempotent consumers
Event notification and routingAzure Event GridResource notifications, business events, and reactive serverless processingAt-least-once delivery attempts, duplicate handling, and event ordering
High-volume event streamingAzure Event HubsIoT telemetry, application logs, clickstream data, and streaming analyticsPartitions, consumer groups, retention, and checkpoint management
Batch data integrationAzure Data FactoryScheduled data movement, bulk synchronization, and ETL/ELT pipelinesData volume, pipeline scheduling, throughput, and transformation requirements
Custom processingAzure FunctionsComplex transformations, custom business logic, and specialized processingCode ownership, scaling, dependencies, and monitoring
Simple application connectivityNative SaaS connectors or webhooksLimited integrations with straightforward requirementsAvoid uncontrolled dependencies around critical business entities

One important point: these services are not mutually exclusive.

A well-designed enterprise integration solution will often combine several of them.

For example, API Management can expose an API, a Logic App can orchestrate a business process, Service Bus can handle asynchronous communication, and Azure Functions can perform specialized processing.

The important thing is to assign each component a clear responsibility.

4. Service Bus vs Event Grid vs Event Hubs: Understanding the Differences

One of the most common architectural discussions is choosing between Azure Service Bus, Event Grid, and Event Hubs.

All three services deal with messaging or events, but their intended use cases are different.

Azure Service Bus – When the Message Represents a Business Command

Service Bus is designed for enterprise messaging.

Consider an order-processing application.

When a customer places an order, the application sends an OrderCreated message to a Service Bus queue or topic.

A downstream application receives the message and processes the order independently.

Service Bus provides capabilities such as:

  • Queues and topics.
  • Message sessions for ordered processing.
  • Dead-letter queues.
  • Duplicate detection.
  • Message scheduling.
  • Transactions.
  • Peek-lock message processing.

An important consideration is that Service Bus does not automatically provide exactly-once business processing.

Messages can be redelivered. Therefore, consumers should be designed to handle duplicate processing safely.

If ordering is required, use message sessions and assign an appropriate SessionId to related messages.

Azure Event Grid – When Something Has Happened

Event Grid is designed for event distribution.

An event communicates that something has happened in a system.

For example:

  • A document was uploaded.
  • An invoice was approved.
  • A customer record was updated.
  • A resource was created.

Multiple subscribers can react to these events independently.

Event Grid supports event filtering, routing, retry policies, and dead-lettering.

However, Event Grid does not guarantee event ordering. It also uses at-least-once delivery attempts, so duplicate deliveries are possible.

Consumers must be designed accordingly.

Azure Event Hubs – When We Need High-Volume Event Streaming

Event Hubs is designed for high-throughput event ingestion and streaming.

Typical use cases include:

  • IoT telemetry.
  • Application logs.
  • Clickstream information.
  • Real-time analytics.
  • Large volumes of application events.

Unlike Service Bus, which is generally used for enterprise commands and messaging workflows, Event Hubs is designed around partitioned event streams and consumer groups.

Quick Comparison

FeatureService BusEvent GridEvent Hubs
Primary purposeEnterprise messagingEvent distributionEvent streaming
Typical dataBusiness messagesNotifications and eventsHigh-volume event streams
CommunicationQueues and topicsEvent routingPartitioned streams
Message orderingSessions support ordered processingNot guaranteedWithin a partition
Dead-letteringBuilt-in dead-letter queuesConfigurable dead-letteringDifferent retention and recovery model
Typical exampleOrder processingBlob uploadedIoT telemetry

My recommendation is to start with the business requirement rather than the service name.

If a business command must be reliably processed, evaluate Service Bus.

If applications need to react to something that happened, evaluate Event Grid.

If the requirement involves continuous, high-volume event ingestion, evaluate Event Hubs.

5. Logic Apps vs Azure Functions: Choosing the Right Approach

Another important decision is whether to implement an integration using Logic Apps or Azure Functions.

Both services can participate in complex integration solutions, but they offer different development models.

When Azure Logic Apps Makes Sense

Logic Apps is a good choice when the requirement involves coordinating multiple systems and services.

For example:

  1. Receive an order request.
  2. Validate the customer.
  3. Retrieve additional information from an ERP system.
  4. Transform the payload.
  5. Send a message to Service Bus.
  6. Notify another application.
  7. Handle failures and exceptions.

Logic Apps provides a workflow-oriented development model and a broad connector ecosystem.

Logic Apps Standard supports stateful and stateless workflows, allowing teams to choose the execution model according to their requirements.

Stateful workflows are useful when execution history and durable workflow state are important.

When Azure Functions Makes Sense

Azure Functions is more appropriate when the integration requires custom code or specialized processing.

Examples include:

  • Complex data transformations.
  • Custom validation logic.
  • Specialized algorithms.
  • Custom protocol handling.
  • Reusable business components.
  • Processing that requires specific libraries.

Functions also support Durable Functions for code-based orchestration scenarios.

A Practical Approach

There is no requirement to choose only one of these services.

A Logic App can call an Azure Function when custom processing is required.

Similarly, an Azure Function can initiate or communicate with a Logic App workflow.

A useful design principle is:

Use Logic Apps to coordinate the workflow and Azure Functions to handle specialized processing where code provides a better solution.

This keeps orchestration and custom business logic reasonably separated.

6. Connecting BizTalk Concepts with Azure Integration Services

For developers and architects who have worked with BizTalk Server, moving to Azure Integration Services involves understanding how familiar integration capabilities are implemented using cloud services.

The concepts of messaging, routing, orchestration, transformation, and exception handling remain important. However, the implementation model changes.

Here is a simplified conceptual mapping.

BizTalk ConceptAzure Integration Approach
Receive Locations and Receive PortsLogic Apps triggers, APIs, and messaging endpoints
Send PortsLogic Apps actions, connectors, and Azure Functions
MessageBox publish-subscribeService Bus topics and subscriptions
OrchestrationsLogic Apps workflows or Durable Functions
MapsLogic Apps transformations, XSLT, or custom Azure Functions
Business Activity MonitoringAzure Monitor, Application Insights, and custom business telemetry
Host InstancesManaged Azure hosting and compute services
EDI processingLogic Apps B2B capabilities and integration account features where applicable
Tracking and correlationCorrelation IDs, distributed tracing, and application telemetry

This is a conceptual comparison rather than a one-to-one replacement mapping.

For example, BizTalk's MessageBox is more than a simple message broker. It provides messaging, routing, subscriptions, and persistence capabilities within the BizTalk runtime.

In Azure, these responsibilities are distributed across different services.

A BizTalk orchestration may be implemented using Logic Apps, but that does not mean every orchestration should automatically become a Logic App.

Similarly, a BizTalk messaging solution may use Service Bus, but the migration design should consider the original routing, transaction, ordering, and error-handling requirements.

The important point is to understand the existing integration pattern before deciding how to implement it in Azure.

7. Real-World Scenario: Designing an Enterprise Order-Processing Integration

Let's consider a typical enterprise environment.

An organization has the following systems:

  • ERP – Manages orders, customers, and inventory.
  • E-commerce application – Receives customer orders.
  • Warehouse management system – Handles order fulfilment.
  • Notification application – Sends customer updates.
  • Reporting platform – Maintains operational and analytical information.

A common mistake would be to create separate direct connections between every application.

Instead, we can introduce a more structured integration architecture.

Step 1: Expose APIs Through API Management

The e-commerce application sends the order request through Azure API Management.

APIM handles API security policies, authentication integration, rate limiting, and request routing.

Step 2: Validate and Orchestrate the Request

A Logic App or an appropriate backend service validates the incoming order and coordinates the required business operations.

Step 3: Publish an Order Message

Once the order is accepted, the integration layer publishes an OrderCreated message to an Azure Service Bus topic.

Step 4: Process the Message Independently

Different subscriptions can receive the message:

  • Warehouse subscription.
  • ERP subscription.
  • Customer notification subscription.

Each downstream application processes the message according to its responsibility.

Step 5: Handle Failures

If the warehouse application is temporarily unavailable, its message processing can retry independently.

Messages that exceed the configured delivery limit can be moved to the dead-letter queue for investigation.

Step 6: Publish Business Events

After successful fulfilment, the warehouse application can publish an OrderDispatched event.

Event Grid can distribute that event to applications that need to react to the change.

Proposed Architecture


Architecture of order-processing flow using Azure Integration Services.
           A decoupled enterprise order-processing architecture using Azure Integration Services.


The following is the logical architecture of the proposed solution:

E-commerce Application → API Management → Order Validation and Orchestration → Service Bus Topic

The Service Bus topic distributes messages to three independent subscriptions:

  • ERP
  • Warehouse Management
  • Customer Notification

After fulfilment, the warehouse application publishes an event:

Warehouse Management → Event Grid → Reporting and Other Event Subscribers

The main advantage is that the ERP system does not need to maintain direct connections with every downstream consumer.

Each consumer has an independent subscription and can process messages according to its own requirements.

This also provides better flexibility when new applications need to consume order information.

Important design consideration: A production implementation should also address transaction boundaries. For example, if an ERP database update and a Service Bus message publication must be treated as one logical operation, consider an outbox pattern or another reliable publication mechanism. Simply completing a database transaction and then publishing a message can introduce a failure window.

8. Before and After: Understanding Integration Sprawl

Let's compare two approaches.

Before: Direct Point-to-Point Integration

Consider an ERP system directly communicating with the e-commerce application, warehouse, CRM, notification system, and reporting platform.

The e-commerce application may also communicate directly with the warehouse and CRM.

As the number of applications grows, the number of dependencies also increases.

In this model:

  • Each application maintains its own communication mechanism.
  • Changes in one application can affect multiple integrations.
  • Error handling becomes inconsistent.
  • Monitoring becomes difficult.
  • Reusing integration logic becomes challenging.

After: Governed Integration Architecture

In a governed integration architecture, communication patterns are selected according to business requirements.

API Management handles API exposure and governance.

Service Bus provides asynchronous messaging.

Event Grid handles event distribution.

Logic Apps coordinates business workflows.

Azure Functions provides custom processing.

This does not mean every application must communicate through one central service.

The objective is to establish appropriate integration boundaries and avoid unnecessary dependencies.

9. Common Integration Design Mistakes to Avoid

Even with the right Azure services, an integration architecture can become difficult to maintain if some basic design principles are overlooked.

Here are a few areas I would pay particular attention to.

9.1 Using Synchronous Communication for Everything

Synchronous communication is useful when an immediate response is required.

However, it introduces runtime dependencies between the calling application and the backend.

If the backend becomes unavailable, the calling application may also experience failures.

For processes that do not require an immediate response, asynchronous messaging can provide better decoupling.

9.2 Treating Every Event as a Business Command

An event and a command represent different things.

A command asks another component to perform an action.

An event communicates that something has already happened.

For example:

  • CreateOrder is a command.
  • OrderCreated is an event.

Maintaining this distinction helps establish clearer responsibilities between applications.

9.3 Implementing Custom Retry Logic Everywhere

Retry mechanisms should be designed consistently.

Repeatedly retrying a failed request without considering the failure type can make an existing problem worse.

For example, retrying a request because of a temporary network issue may be reasonable.

Retrying continuously because of an invalid business payload is unlikely to solve anything.

Define retry policies, maximum delivery attempts, dead-letter handling, and operational ownership.

9.4 Ignoring Duplicate Message Processing

Message delivery and business processing are not necessarily the same thing.

A message can be delivered more than once.

Therefore, consumers should implement idempotency wherever duplicate processing could create incorrect business results.

For example, processing the same order message twice should not create two separate business orders.

Use stable business identifiers or message identifiers to identify previously processed transactions.

9.5 Creating Shared Integration Components Without Clear Ownership

Reusable components are useful, but they also need ownership.

If multiple teams depend on a shared transformation service, who maintains it? Who approves schema changes? Who handles production failures?

These questions should be addressed during architecture design rather than after deployment.

10. Three Pillars of Practical Integration Governance

An Integration Decision Matrix is useful, but it is only one part of an effective governance approach.

To make it successful, I would focus on three areas.

10.1 Establish Golden Paths

Provide developers with approved integration templates and reference implementations.

These should cover:

  • Standard logging.
  • Correlation ID propagation.
  • Error handling.
  • Retry policies.
  • Key Vault integration.
  • Managed identity.
  • Infrastructure deployment.
  • CI/CD pipelines.

For example, a team creating a new Logic App should not have to independently decide how to implement basic monitoring, authentication, and deployment every time.

Providing reusable templates makes it easier for teams to follow architectural standards.

10.2 Follow Contract-First Integration

Define the communication contract before implementing the integration.

For APIs, use OpenAPI specifications.

For events and messages, define the schema, required fields, versioning approach, and compatibility rules.

This is particularly important when multiple applications consume the same business information.

A change in an ERP system should not unexpectedly break downstream applications.

Contract-first design helps establish clear expectations between producers and consumers.

10.3 Build Observability and Cost Management into the Architecture

Monitoring should not be treated as an activity that happens after deployment.

Every important integration should have a defined monitoring strategy.

Correlation IDs

Propagate a consistent business transaction or correlation identifier across APIs, Logic Apps, Service Bus messages, and backend applications.

This makes it easier to trace a transaction across different components.

Centralized monitoring

Use Azure Monitor and Application Insights where appropriate to capture execution details, failures, dependencies, and performance information.

Dead-letter monitoring

Configure alerts for messages entering Service Bus dead-letter queues.

A dead-letter queue that nobody monitors can become a hidden operational problem.

Resource tagging

Apply standard Azure resource tags such as:

  • BusinessDomain
  • Environment
  • ApplicationName
  • CostCenter
  • Owner

Use Azure Policy where appropriate to enforce tagging standards.

Cost reviews

Review workflow executions, messaging operations, compute utilization, polling frequency, and storage consumption regularly.

The objective is to understand not only whether an integration works, but also whether it operates efficiently.

11. How to Introduce the Decision Matrix into Architecture Reviews

The decision matrix should become part of the normal solution-design process.

Whenever a new integration requirement is proposed, ask the delivery team to explain the following:

  1. What is the business requirement?
  2. What communication pattern is required?
  3. Why was the selected Azure service chosen?
  4. What alternatives were evaluated?
  5. How will failures and retries be handled?
  6. How will messages or transactions be monitored?
  7. What are the expected operational costs?
  8. Who owns the integration after deployment?

For example, suppose a team proposes a direct webhook between the ERP system and the e-commerce application.

Instead of rejecting the proposal immediately, evaluate the actual requirement.

If the integration is a simple, non-critical notification consumed by one application, a webhook may be perfectly reasonable.

However, if the same order information must be delivered to multiple downstream applications, with independent processing, retries, and message recovery, a Service Bus topic may be a more appropriate design.

This is how governance should work.

It should guide technical decisions rather than create unnecessary approval processes.

12. A Practical Integration Decision Flow

The following questions provide a simple starting point for selecting an integration approach.

Question 1: Does the application require an immediate response?

If yes, consider API Management with an appropriate backend API or Azure Function.

If not, evaluate asynchronous messaging, event-driven processing, or batch integration.

Question 2: Is the requirement about sending a business command?

Consider Azure Service Bus when durable enterprise messaging, independent consumers, and controlled message processing are required.

Question 3: Is the requirement about notifying other applications that something has happened?

Consider Azure Event Grid for event distribution and routing.

Question 4: Do we need to process a continuous stream of high-volume events?

Evaluate Azure Event Hubs.

Question 5: Does the process involve multiple business steps and connectors?

Evaluate Azure Logic Apps.

For code-intensive orchestration, also consider Durable Functions.

Question 6: Is the requirement primarily bulk data movement?

Evaluate Azure Data Factory.

This decision flow is a starting point, not a replacement for detailed architecture evaluation.

Some requirements will involve more than one service. For example, a Logic App may receive an event from Event Grid, invoke an Azure Function, and publish a command to Service Bus.

The final architecture should reflect the business process and operational requirements.

13. Final Thoughts

Enterprise integration architecture is not about using every Azure service available or introducing additional layers just because they are part of a reference architecture.

It is about understanding the business requirement, selecting the appropriate communication pattern, and designing a solution that remains manageable as the number of applications and integrations increases.

A good Integration Decision Matrix provides a common language for architects, developers, and delivery teams.

It helps answer some important questions:

  • Should this integration be synchronous or asynchronous?
  • Do we need a message broker or an event-routing service?
  • Should the business process be orchestrated through Logic Apps?
  • Is custom processing better handled through Azure Functions?
  • How will we handle failures, duplicates, and operational monitoring?

There is no single Azure service that solves every integration requirement.

The right architecture is usually a combination of services, each with a clearly defined responsibility.

The real objective is not to build a more complicated integration platform. It is to make the integration landscape simpler to understand, easier to operate, and more predictable to maintain.

How does your organization approach integration architecture reviews? Do you follow a predefined integration standard, or do individual project teams make technology decisions based on their requirements?

I would be interested in hearing how other integration architects approach this challenge.



Learn More about Logic App

Post a Comment

If you have any suggestions or questions or want to share something then please drop a comment

Previous Post Next Post