Based on Oracle official documentation: Common Integration Style Pitfalls and Design Best Practices.
Use Descriptive Names+
Problem: Poor naming conventions make integrations hard to understand and maintain.
Best Practice
Use descriptive names for integrations, connections, and lookups
Follow consistent naming conventions across all artifacts
Include version information in names where applicable
❌ Integration_1, Conn_ERP
✅ CustomerSync_SAP_to_SFDC_v1, SAP_ECC_Connection
Create Reusable Assets+
Problem: Duplicate configurations and logic across multiple integrations.
Create reusable connections for common endpoints
Use lookup tables for configuration data
Build template integrations for common patterns
Create shared XSDs for common data structures
Single Responsibility Principle+
Problem: Complex integrations that try to do too much.
Each integration should have a single, well-defined purpose
Break complex processes into smaller, focused integrations
Use orchestration patterns to coordinate multiple integrations
Efficient Payload Handling+
Use pagination for large data sets
Implement filtering to reduce data volume
Process data in chunks rather than all at once
Use file-based processing for very large datasets
⚠️ OIC Limits
10MB string size limit
1GB file attachment limit
6-hour max integration duration
Timeout Management+
Use asynchronous patterns for long-running processes
Implement proper timeout configurations
Use polling patterns for external system availability
Set appropriate retry intervals
⏱️ Critical Timeouts
JavaScript: 15 seconds
XSLT: 120 seconds
Sync integrations: 300 seconds
Async integrations: 6 hours
Loop Optimization+
Use 'for-each' instead of 'while' loops when possible
Implement loop counters to prevent infinite loops
Use batch processing for multiple records
Avoid nested loops with large datasets
🔢 Loop Limits
While loops: 5,000 max iterations
For-each loops: Unlimited
Tracked iterations: 1,000 max
Comprehensive Error Handling+
Implement error handling in every scope
Use custom error messages for better troubleshooting
Configure proper retry mechanisms
Set up notifications for critical failures
Use error hierarchies for different error types
Monitoring and Logging+
Use OIC activity stream for monitoring
Implement custom logging for business events
Track key performance metrics
Set up dashboards for integration health
Use correlation IDs for tracking across systems
📊 Monitoring Limits
20,000 non-error tracking events
30,000 error tracking events
2,000 maximum errors
Security Implementation+
Use OIC credential management for sensitive data
Implement proper authentication for all connections
Use secure protocols (HTTPS, SFTP)
Validate all input data
Follow principle of least privilege for roles
⏱️ Time Limits
Sync Integration: 5 minutes
Async Integration: 6 hours
JavaScript: 15 seconds
XSLT: 120 seconds
📊 Size Limits
String Variables: 10,000 chars
File Attachments: 1 GB
Structured Payloads: 100 MB
Activity Stream: 32 KB/payload
🔢 Quantity Limits
Concurrent Sync: 2,000
While Loops: 5,000
Lookup Entries: 10,000
Tracking Events: 20,000
Design Phase
Single, well-defined purpose
Descriptive naming conventions
Error handling strategy
Performance considerations
Security requirements
Development Phase
Comprehensive error handling
Proper logging and monitoring
Efficient data processing
Configuration management
Testing strategy
Deployment Phase
Performance testing completed
Error scenarios tested
Monitoring configured
Documentation updated
Support procedures defined
Based on Oracle official documentation: Avoid Common Integration Style Pitfalls.
The Monolithic Integration
Problem
Creating a single, overly complex integration that handles multiple business processes. Symptoms include one integration performing multiple unrelated operations, extremely complex mapping, and mixing multiple message exchange patterns in one flow.
Solution
Create separate integrations for distinct business processes. Use orchestration to coordinate between smaller integrations. Implement service composition patterns and design around single responsibility principle.
Tight Coupling
Problem
Designing integrations tightly bound to specific source or target system implementations, with direct dependencies on data structures and hardcoded field mappings. Integration breaks when source/target systems change.
Solution
Implement canonical data models. Use abstraction layers between systems, create reusable transformation maps, and design for loose coupling and flexibility.
Poor Error Handling Design
Problem
Inadequate error handling strategy leading to unpredictable integration behavior. Errors not properly caught, no clear error notification or escalation, and inconsistent error handling across integrations.
Solution
Design error handling strategy upfront. Implement error handling at global and local scopes, use consistent error notification patterns, and create an error classification system.
Poor Naming Conventions
Problem
Using non-descriptive names like "Integration_1" or "Connection_1" with no consistent naming pattern. Names don't indicate purpose or function, making it difficult to identify integration relationships.
Solution
Establish naming conventions early. Include system names and purpose in artifact names, use consistent patterns, and include version information where applicable.
Not Creating Reusable Assets
Problem
Duplicating configurations and logic instead of creating reusable components. Multiple connections to the same endpoint with different names, copy-paste integration patterns, and higher maintenance overhead.
Solution
Create shared connections for common endpoints, use lookup tables for configuration data, build template integrations for common patterns, and establish asset reuse guidelines.
Overly Complex Transformations
Problem
Creating extremely complex data mappings that are hard to maintain. Single transformation handling multiple business rules, deeply nested conditional logic, and business logic embedded in data transformations.
Solution
Break complex maps into smaller, focused maps. Separate business logic from data transformation, use multiple simple maps, and document mapping rules clearly.
Ignoring OIC Service Limits
Problem
Designing without considering OIC platform constraints. Large payloads causing memory issues, long-running processes hitting timeout limits, and excessive logging overwhelming activity streams.
Solution
Design within OIC constraints from the start. Implement pagination for large datasets, use asynchronous patterns for long operations, and monitor and optimize resource usage.
Inefficient Loop Patterns
Problem
Using 'while' loops where 'for-each' is appropriate, nested loops with large datasets, no loop termination conditions, and processing all data in memory.
Solution
Prefer 'for-each' over 'while' loops. Implement batch processing for large datasets, use pagination to process in chunks, and set reasonable loop counters and limits.
Poor Connection Management
Problem
Creating new connections for each invocation, not reusing established connections, inappropriate connection pool sizes, and long connection establishment times.
Solution
Reuse connections where possible, configure appropriate connection pooling, monitor connection usage and performance, and implement connection retry strategies.
Inefficient File Processing
Problem
Loading large files entirely into memory, not using segmentation for large files, and ignoring file size limits. Read Entire File: 100MB max; Read with segments: 1GB max.
Solution
Use 'Read File in Segments' for files over 100MB, process files in chunks, and choose appropriate file operations for each use case.
Poor Large Data Handling
Problem
Fetching all records without pagination, processing large datasets in single transactions, no batching for bulk operations, and memory-intensive data transformations.
Solution
Implement pagination for large result sets, use batch processing for bulk operations, process data in manageable chunks, and monitor memory usage during large operations.
Insecure Data Handling
Problem
Hardcoded credentials in integrations, unencrypted sensitive data transmission, lack of input validation, and inadequate access controls.
Solution
Use OIC credential management for sensitive data, implement proper authentication for all connections, validate all input data, and use secure protocols (HTTPS, SFTP).
📋 Anti-Patterns Quick Reference
🚫 Common Design Pitfalls
Monolithic integrations
Tight coupling to systems
Poor error handling design
Inconsistent naming
No reusable assets
⚡ Performance Pitfalls
Ignoring OIC limits
Inefficient loops
Poor connection management
Large file processing issues
No pagination for large data
Rate your integration by checking applicable items. Score updates live.
🏗️ Design Quality 25 Points
Single, well-defined purpose
Descriptive naming conventions
Loose coupling between systems
Robust reprocessing mechanism
Comprehensive error handling
⚡ Performance 20 Points
Respects OIC service limits
Efficient data processing
Appropriate connection usage
Optimized transformations
🔧 Maintainability 25 Points
Consistent patterns
Clear documentation
Reusable components
Easy to test and debug
Appropriate logging
0
/ 70 Points
Start checking items above
Need help with your OIC implementation?
Our Oracle Integration Cloud specialists are ready to review your architecture and guide you to best-practice patterns.
