Having implemented both approaches across multiple enterprises, the decision framework should be based on your specific context rather than a one-size-fits-all recommendation.
Integration Scalability Analysis:
The scalability question has multiple dimensions:
1. Volume Scalability: How many transactions per hour will flow through each integration? Integration Hub connectors handle moderate volumes well (hundreds to low thousands of transactions per hour), but for high-volume scenarios (tens of thousands per hour), custom APIs with optimized connection pooling and batch processing perform better.
2. Complexity Scalability: How complex are your integration scenarios? If you’re doing simple CRUD operations (create orders, update customers), Integration Hub is efficient. If you need complex multi-step transactions, conditional logic based on business rules, or orchestration across multiple systems, custom APIs provide better structure and testability.
3. System Scalability: How many systems will you integrate over the next 3-5 years? For 2-3 systems, Integration Hub’s visual approach is manageable. For 10+ systems, the configuration management overhead becomes significant, and code-based approaches scale better.
Upgrade Impact Reality:
This is where practical experience diverges from vendor promises:
Integration Hub Upgrade Impact:
- Pre-built connectors may have breaking changes between Creatio versions (we’ve seen this in 3 of our last 5 major upgrades)
- Visual configurations sometimes don’t migrate cleanly, requiring manual reconfiguration
- Connector feature sets may change (features deprecated or moved to different modules)
- Documentation for connector changes is often incomplete
- Testing all integration scenarios after upgrade is time-consuming because configurations are harder to automate
Custom API Upgrade Impact:
- Your API code is independent of Creatio version (assuming you’re using standard REST/SOAP interfaces)
- Upgrades mainly affect the Creatio-side integration processes, not your API layer
- Changes are explicit in your codebase and can be reviewed, tested, and version-controlled
- Regression testing is automated through your API test suite
- Downside: If Creatio changes its integration interfaces (rare but happens), you need to adapt your code
Maintenance Overhead Comparison:
Over a 3-year period with 3 ERP integrations, typical maintenance effort:
Integration Hub Approach:
- Initial setup: 2-3 months (faster than custom APIs)
- Ongoing maintenance: 15-20% of one FTE per year
- Connector updates when vendors release new versions
- Configuration adjustments for business logic changes
- Troubleshooting integration failures (harder without detailed logging)
- Documentation updates (visual configs are hard to document comprehensively)
- Major upgrade impact: 3-4 weeks of testing and remediation
Custom API Approach:
- Initial development: 4-6 months (slower than Integration Hub)
- Ongoing maintenance: 10-15% of one FTE per year
- Code updates for business logic changes
- ERP API version updates (when ERPs change their interfaces)
- Infrastructure maintenance (API hosting, monitoring)
- Advantage: Issues are faster to diagnose with proper logging
- Major upgrade impact: 1-2 weeks of testing (mostly Creatio-side process updates)
Recommendation Framework:
Use Integration Hub When:
- Integrating 1-3 systems with standard CRUD operations
- Business logic is straightforward without complex transformations
- You lack dedicated integration development resources
- Time-to-market is critical (need integration running in weeks, not months)
- Your organization prefers low-code approaches and visual configuration
- Transaction volumes are moderate (< 5,000 per hour per integration)
Use Custom APIs When:
- Integrating 5+ systems or planning significant expansion
- Complex business logic, multi-step transactions, or orchestration requirements
- High transaction volumes requiring performance optimization
- Strong preference for code-based approaches with CI/CD pipelines
- Need detailed control over error handling, logging, and monitoring
- Independent upgrade cycles are important (Creatio upgrades shouldn’t disrupt integrations)
- Integration scenarios include complex data transformations or validation logic
Hybrid Approach (Often the Best Choice):
For your specific scenario with three ERPs, consider:
-
Use Integration Hub for SAP: SAP connector is mature and handles most standard scenarios well. Extend with custom business processes in Creatio for complex logic.
-
Use Custom API for Oracle: Oracle integrations often need custom optimization and complex transaction handling. Build a dedicated integration service.
-
Use Custom API for Legacy ERP: Legacy systems rarely have good pre-built connectors, and you’ll need custom logic anyway.
This hybrid approach balances time-to-market (leverage SAP connector) with long-term maintainability (custom APIs for complex scenarios).
Critical Success Factors (Regardless of Approach):
-
Abstraction Layer: Don’t let integration implementation details leak into your business processes. Create a service layer that business processes call, whether that service uses Integration Hub or custom APIs underneath.
-
Comprehensive Monitoring: Implement detailed logging, error tracking, and performance monitoring. This is where custom APIs have an advantage - you control the instrumentation.
-
Automated Testing: Build a comprehensive test suite that validates integration scenarios. This is crucial for both approaches but easier to automate with custom APIs.
-
Documentation: Document integration logic, data mappings, error handling, and operational procedures. Visual configurations need documentation just as much as code.
-
Change Management: Establish processes for handling changes in source systems, business requirements, and Creatio versions.
The answer isn’t purely technical - it depends on your team’s capabilities, organizational preferences, and long-term integration strategy. Most successful large-scale implementations use a hybrid approach, leveraging Integration Hub where it adds value while building custom APIs for complex scenarios that require more control.