When to use integration hub vs direct API calls for third-party integrations

CRM SAP Customer Experience (SAP CX)
, , , , , , , ,
1

We’re architecting integrations between SAP CX and multiple third-party systems (payment gateway, shipping provider, analytics platform, inventory system). The team is debating whether to route everything through Integration Hub or use direct API-to-API calls for some services.

Integration Hub adds a layer of abstraction and provides built-in monitoring, but I’m concerned about:

  • Additional latency from the extra hop
  • Complexity of managing integration flows vs straightforward API calls
  • Whether the monitoring benefits justify the overhead for simple integrations

Direct API calls seem simpler for basic scenarios (like real-time inventory checks), but we’d need to build our own error handling and monitoring. For complex workflows (like order fulfillment with multiple steps), Integration Hub’s orchestration capabilities seem valuable.

What’s been your experience? Are there clear use cases where one approach is definitively better? How do you decide the integration architecture for different scenarios?

2

Don’t underestimate the operational benefits of Integration Hub. When third-party APIs change (and they will), having transformations centralized in Integration Hub means updating one place vs hunting through application code. We had a payment gateway change their response format - took 30 minutes to update the Integration Hub mapping vs what would have been days finding and testing all direct API call sites.

3

Monitoring and error handling considerations are huge. We started with direct API calls to save time, but operational overhead became unsustainable. Every integration needed custom logging, error handling, retry logic, and alerting. When we consolidated through Integration Hub, our monitoring improved dramatically - single pane of glass for all integrations, standardized error patterns, built-in circuit breakers. The latency concern is real but typically adds only 50-100ms, which is acceptable for most CRM workflows.

4

We use a hybrid approach. Real-time, high-volume, simple requests (like inventory checks, address validation) go direct API to minimize latency. Complex workflows with multiple systems, transformations, or business logic go through Integration Hub. The orchestration and retry capabilities are invaluable for multi-step processes. Our rule of thumb: if it’s a single synchronous call with no transformation, go direct. Everything else uses Integration Hub.

5

Consider your scaling requirements too. Direct API calls scale horizontally with your CX instance, but you’re limited by third-party API rate limits and need to implement rate limiting logic yourself. Integration Hub provides built-in throttling and queuing. When our order volume spiked during holiday season, Integration Hub’s queuing prevented us from hitting shipping API rate limits. With direct calls, we would have needed custom queuing infrastructure.

6

Based on extensive experience with SAP CX integration architectures, here’s a comprehensive framework for making this decision.

Integration Pattern Selection Framework:

Use Direct API Calls when:

  • Synchronous, latency-sensitive operations (<200ms SLA) like real-time inventory checks, address validation, credit checks during checkout
  • Simple request-response patterns with no transformation logic
  • High-volume, lightweight operations (>1000 requests/minute) where Integration Hub overhead impacts performance
  • Third-party API is stable with infrequent changes
  • No complex error handling or retry requirements
  • Example: Real-time product availability check during cart updates

Use Integration Hub when:

  • Complex multi-step workflows requiring orchestration (order-to-cash, quote-to-order)
  • Asynchronous or batch processing scenarios where latency isn’t critical
  • Data transformation or enrichment needed between systems
  • Integration with multiple downstream systems for single business process
  • Requirement for sophisticated error handling, retry logic, or compensation transactions
  • Need for centralized monitoring and alerting across integrations
  • Example: Order fulfillment involving payment processing, inventory reservation, shipping coordination, and customer notifications

Monitoring and Error Handling Comparison:

Integration Hub provides out-of-box capabilities that would require significant custom development with direct APIs:

  • Unified monitoring dashboard with integration flow visibility
  • Built-in retry policies with exponential backoff
  • Circuit breaker patterns to prevent cascade failures
  • Message queuing for handling traffic spikes
  • Centralized logging with correlation IDs across integration steps
  • Dead letter queues for failed message handling
  • Pre-built connectors with error handling for common services

With direct APIs, you must implement:

  • Custom logging infrastructure per integration
  • Manual retry logic in application code
  • Rate limiting and throttling mechanisms
  • Error alerting and notification systems
  • Integration health monitoring and dashboards

The operational overhead of maintaining custom error handling across multiple direct integrations typically exceeds the development effort of using Integration Hub.

Scalability Considerations:

Integration Hub advantages:

  • Built-in rate limiting and throttling respects third-party API constraints
  • Message queuing handles traffic bursts without overwhelming downstream systems
  • Horizontal scaling managed by platform
  • Async processing patterns prevent timeout issues
  • Connection pooling and resource management handled automatically

Direct API scaling challenges:

  • Application must implement rate limiting per third-party service
  • No built-in queuing - traffic spikes can cause failures
  • Connection management responsibility on application
  • Synchronous patterns can cause thread exhaustion under load

Recommended Hybrid Architecture:

Implement a tiered approach based on integration characteristics:

Tier 1 - Direct API: Real-time, simple, high-volume (inventory checks, address validation, pricing lookups) Tier 2 - Integration Hub Sync: Moderate complexity, acceptable latency (payment processing, customer verification) Tier 3 - Integration Hub Async: Complex workflows, batch operations (order fulfillment, nightly syncs, data migration)

For your specific examples:

  • Payment gateway: Integration Hub (complex error handling, PCI compliance logging, retry requirements)
  • Shipping provider: Integration Hub (multi-step workflow, label generation, tracking updates)
  • Analytics platform: Integration Hub async (batch data transfer, no real-time requirement)
  • Inventory system: Hybrid - real-time checks via direct API, bulk updates via Integration Hub

This approach balances performance optimization with operational maintainability and provides the flexibility to evolve your integration architecture as requirements change.