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.
| Parameter | Questions to Consider |
|---|---|
| Communication pattern | Is it synchronous, asynchronous, event-driven, or batch-based? |
| Latency | Does the business require an immediate response, or can processing happen later? |
| Message volume | Are we processing individual transactions or millions of events? |
| Payload size | Are messages small JSON documents, XML files, or large datasets? |
| Ordering | Must messages be processed in a particular sequence? |
| Delivery requirements | Is at-least-once delivery sufficient? What happens if a message is delivered twice? |
| State management | Does the integration require a long-running business process? |
| Transformation | Is simple mapping sufficient, or do we need complex XML, JSON, EDI, or flat-file processing? |
| Security | Are authentication, authorization, private connectivity, or partner security requirements involved? |
| Operations | How will we monitor, retry, troubleshoot, and recover failed transactions? |
| Cost | What 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 Requirement | Recommended Azure Services | When to Use | Important Considerations |
|---|---|---|---|
| Synchronous request/reply | API Management + Azure Functions or backend API | Real-time application requests, partner APIs, and immediate responses | Backend availability, throttling, timeout behavior, and API security |
| Stateful business orchestration | Azure Logic Apps Standard | Multi-step workflows, ERP integration, B2B processes, and connector-based integrations | Workflow state, execution history, connector limitations, and hosting model |
| Reliable asynchronous messaging | Azure Service Bus | Business commands, order processing, and decoupled application communication | Sessions, duplicate detection, dead-letter queues, and idempotent consumers |
| Event notification and routing | Azure Event Grid | Resource notifications, business events, and reactive serverless processing | At-least-once delivery attempts, duplicate handling, and event ordering |
| High-volume event streaming | Azure Event Hubs | IoT telemetry, application logs, clickstream data, and streaming analytics | Partitions, consumer groups, retention, and checkpoint management |
| Batch data integration | Azure Data Factory | Scheduled data movement, bulk synchronization, and ETL/ELT pipelines | Data volume, pipeline scheduling, throughput, and transformation requirements |
| Custom processing | Azure Functions | Complex transformations, custom business logic, and specialized processing | Code ownership, scaling, dependencies, and monitoring |
| Simple application connectivity | Native SaaS connectors or webhooks | Limited integrations with straightforward requirements | Avoid 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
| Feature | Service Bus | Event Grid | Event Hubs |
|---|---|---|---|
| Primary purpose | Enterprise messaging | Event distribution | Event streaming |
| Typical data | Business messages | Notifications and events | High-volume event streams |
| Communication | Queues and topics | Event routing | Partitioned streams |
| Message ordering | Sessions support ordered processing | Not guaranteed | Within a partition |
| Dead-lettering | Built-in dead-letter queues | Configurable dead-lettering | Different retention and recovery model |
| Typical example | Order processing | Blob uploaded | IoT 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:
- Receive an order request.
- Validate the customer.
- Retrieve additional information from an ERP system.
- Transform the payload.
- Send a message to Service Bus.
- Notify another application.
- 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 Concept | Azure Integration Approach |
|---|---|
| Receive Locations and Receive Ports | Logic Apps triggers, APIs, and messaging endpoints |
| Send Ports | Logic Apps actions, connectors, and Azure Functions |
| MessageBox publish-subscribe | Service Bus topics and subscriptions |
| Orchestrations | Logic Apps workflows or Durable Functions |
| Maps | Logic Apps transformations, XSLT, or custom Azure Functions |
| Business Activity Monitoring | Azure Monitor, Application Insights, and custom business telemetry |
| Host Instances | Managed Azure hosting and compute services |
| EDI processing | Logic Apps B2B capabilities and integration account features where applicable |
| Tracking and correlation | Correlation 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
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:
CreateOrderis a command.OrderCreatedis 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:
- What is the business requirement?
- What communication pattern is required?
- Why was the selected Azure service chosen?
- What alternatives were evaluated?
- How will failures and retries be handled?
- How will messages or transactions be monitored?
- What are the expected operational costs?
- 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
- How to configure Logic App Standard workflow behind Azure APIM
- How to Query Azure Table storage from Logic App | How to filter results of Azure Table storage from Logic App
- Understanding expressions in Logic Apps | Frequently used expressions in Logic Apps | What is expressions in Logic App
- How to use Logic app Run History | How to troubleshoot Logic App workflow execution
- Logic App and Slack - Sending messages to slack channel | Logic app and slack integration | Connecting Logic App to Slack channel
- How to access Application settings fields value from Logic app Standard workflow | Using Application settings as configuration store for Logic app standard workflow
- Developing Logic app standard workflow which uses Map locally and deploying to Azure
- Developing Logic App Standard Workflow Using Visual Studio Code | Create Logic App Standard Workflow Using Visual Studio Code
- Logic App - Xml to Json using Liquid Map | Append in Liquid Map
- How to use Azure Event Grid Custom Topic | Publishing and Subscribing from Azure Event Grid Custom Topic using Logic App
- Using Azure Storage Account Table as Config Store for Logic Apps | How to read and write from Logic App to Azure Storage Account Table
- Get Logic App Name in Logic App
- Difference between Logic App Consumption and Logic App Standard
- Getting Started with Logic App Standard | Overview of Logic App Standard | Basics of Logic App Standard
- How to find count of Logic App executions using Azure Portal
- Azure Functions vs Azure Logic App | Difference between Azure Functions and Azure Logic App
- Getting started with Logic App : Liquid Map | Using Liquid template in Logic app
- How to get actual error message of Scope in Logic App | Exception Handling in Logic app
- Interview questions and answers on Logic Apps | Interview questions for azure logic app developers
- How to execute Stored Procedure in Logic App | How to connect to SQL in Logic App
- How to get current date in logic app | How to format date time in Logic App
- BizTalk Developer getting started with Logic App
- Getting Started with Logic Apps - Fundamentals
- Getting Started with Logic Apps - Enterprise Application Integration
- Getting Started with Logic Apps - AS2
- Getting Started with Logic Apps - EDI X12 Fundamentals
- Getting Started with Logic Apps - XML to EDI X12
- Getting Started with Logic Apps - EDI X12 to XML
- Getting Started with Logic Apps - What happened to the Request?
- Inserting Multiple Records In On Prem SQL Using Logic App
- Inserting data in On Premises SQL Database using Logic Apps
- Installing and Configuring On Premises Data Gateway - By adding user to Active Directory
- XML Batching(Aggregation) in Logic App
- Batching(Aggregating) messages in Logic App
- Debatching(Splitting) JSON Message in Logic Apps - ForEach and SplitOn
- Debatching(Splitting) XML Message in Logic Apps - ForEach and SplitOn
- Securing Logic App with Azure Active Directory authentication
- Removing ns0: prefix from xml output from BizTalk/Logic app XSLT map
- Using Managed Identity in Logic Apps for Calling Active Directory Secured Function App
- Logic Apps : Fetching ISA and GS Segment Values From Interchange Envelope and Mapping
- Logic Apps : For Each Inside a For Each - Fetching values from field in an array inside an array
