---
# === IDENTITY ===
id: business/erp-integration/oracle-erp-cloud-coexistence-patterns/2026
canonical_question: "How do you run Oracle EBS and Fusion Cloud simultaneously during migration?"
aliases:
  - "Oracle EBS Fusion Cloud coexistence architecture"
  - "Running EBS and Oracle Cloud ERP side by side"
  - "Oracle dual-ERP coexistence integration patterns"
  - "EBS Fusion coexistence data synchronization"
entity_type: erp_integration
domain: business > erp-integration > oracle-erp-cloud-coexistence-patterns
region: global
jurisdiction: global
temporal_scope: 2024-2028

# === SYSTEM PROFILE ===
systems:
  - name: "Oracle E-Business Suite"
    vendor: "Oracle"
    version: "12.2"
    edition: "All Editions"
    deployment: "on-premise"
    api_surface: "PL/SQL, SOAP/REST (ISG)"
  - name: "Oracle Fusion Cloud ERP"
    vendor: "Oracle"
    version: "Release 25A"
    edition: "Enterprise"
    deployment: "cloud"
    api_surface: "REST, SOAP, FBDI"
  - name: "Oracle Integration Cloud (OIC)"
    vendor: "Oracle"
    version: "Generation 3"
    edition: "Standard/Enterprise"
    deployment: "cloud"
    api_surface: "REST, Adapters"

# === VERIFICATION ===
last_verified: 2026-03-09
confidence: 0.82
version: 1.0
first_published: 2026-03-09

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "25A — new ERP Cloud business events for cross-system sync"
  next_review: 2026-09-05
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "OIC Connectivity Agent required for on-premise EBS — must run on dedicated VM or OCI compute"
  - "EBS Business Events must be registered in ISG before OIC can subscribe"
  - "Cross-system master data sync requires single source of truth designation per entity"
  - "Fusion Cloud quarterly updates are mandatory — coexistence integrations must be tested every quarter"
  - "OIC message pack consumption doubles during coexistence (bidirectional flow)"
  - "GL period close must be coordinated across both systems — timing mismatch causes reconciliation gaps"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "Planning initial migration from EBS to Fusion Cloud"
    use_instead: "business/erp-integration/oracle-ebs-to-fusion-migration/2026"
  - condition: "Need Fusion Cloud API reference only (no EBS involvement)"
    use_instead: "Oracle Fusion Cloud REST API documentation"
  - condition: "Running PeopleSoft or JD Edwards alongside Fusion Cloud"
    use_instead: "Vendor-specific coexistence guides"

# === AGENT HINTS ===
inputs_needed:
  - key: coexistence_scope
    question: "Which modules are running in each system?"
    type: choice
    options:
      - "Financials in Fusion, Procurement/SCM still in EBS"
      - "Procurement in Fusion, Financials still in EBS"
      - "HCM in Fusion Cloud, ERP still in EBS"
      - "Specific modules split across both systems"
  - key: sync_direction
    question: "What is the primary data flow direction?"
    type: choice
    options:
      - "EBS → Fusion (EBS is source of truth)"
      - "Fusion → EBS (Fusion is source of truth)"
      - "Bidirectional (varies by data entity)"
  - key: coexistence_duration
    question: "How long will coexistence last?"
    type: choice
    options:
      - "< 6 months (short transition)"
      - "6-18 months (standard phased migration)"
      - "> 18 months (long-term hybrid)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/oracle-erp-cloud-coexistence-patterns/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-09)"

# === RELATED UNITS ===
related_kos:
  depends_on:
    - id: "business/erp-integration/oracle-ebs-to-fusion-migration/2026"
      label: "EBS to Fusion Cloud migration overview — prerequisite context"
  related_to:
    - id: "business/erp-integration/oracle-redwood-ui-impact-integrations/2026"
      label: "Redwood UI changes during coexistence period"
  solves: []
  alternative_to: []
  often_confused_with: []

# === SOURCES ===
sources:
  - id: src1
    title: "Use Oracle Integration to Connect E-Business Suite with Financials Cloud"
    author: Oracle
    url: https://docs.oracle.com/en/solutions/oracle-ebs-erpcloud-integration/
    type: official_docs
    published: 2024-10-01
    reliability: authoritative
  - id: src2
    title: "Oracle Fusion EBS Coexistence Q&A"
    author: IT Convergence
    url: https://www.itconvergenceinsights.com/oracle-fusion-ebs-coexistence-faqs
    type: community_resource
    published: 2024-06-15
    reliability: moderate_high
  - id: src3
    title: "Oracle Fusion Cloud ERP Integrations Guidelines Using Oracle PaaS"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/oracle-fusion-cloud-erp-applications-integrations-guidelines-patternsuse-cases-using-oracle-paas
    type: technical_blog
    published: 2024-08-15
    reliability: authoritative
  - id: src4
    title: "Using the Oracle E-Business Suite Adapter with Oracle Integration"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/paas/integration-cloud/e-business-adapter/oracle-e-business-suite-adapter-capabilities.html
    type: official_docs
    published: 2024-09-01
    reliability: authoritative
  - id: src5
    title: "EBS to Fusion Cloud Migration — Handling External System Coexistence and ID Conflicts"
    author: Oracle Community
    url: https://forums.oracle.com/ords/apexds/post/ebs-to-fusion-cloud-migration-handling-external-system-coex-4201
    type: community_resource
    published: 2024-11-15
    reliability: moderate_high
  - id: src6
    title: "Event Driven Integrations with OIC"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/event-driven-integrations-primer
    type: technical_blog
    published: 2024-07-10
    reliability: authoritative
---

# Oracle EBS and Fusion Cloud Coexistence Patterns

## TL;DR

- **Bottom line**: Running EBS and Fusion Cloud simultaneously requires Oracle Integration Cloud (OIC) as the middleware layer, with clear source-of-truth designations per data entity and bidirectional sync flows for shared master data.
- **Key limit**: OIC Connectivity Agent is mandatory for on-premise EBS — it must run on a dedicated VM; OIC message pack consumption roughly doubles during coexistence due to bidirectional flows.
- **Watch out for**: ID conflicts when both systems generate document numbers (PO numbers, invoice numbers) independently — implement non-overlapping number ranges or cross-reference mapping tables.
- **Best for**: Organizations migrating module-by-module from EBS to Fusion Cloud over 6-24 months, needing seamless cross-system operations during the transition.
- **Authentication**: OIC handles credential management for both systems — EBS via ISG username/password through Connectivity Agent, Fusion via OAuth 2.0 JWT bearer through native adapter.

## System Profile

This card covers the technical architecture and integration patterns for running Oracle E-Business Suite 12.2 and Oracle Fusion Cloud ERP simultaneously during a phased migration. It addresses data synchronization, master data governance, cross-system transaction flow, reporting consolidation, and operational considerations. This card assumes the migration plan is already defined — for migration planning, see the EBS to Fusion Cloud migration card. [src1]

| System | Role | API Surface | Direction |
|---|---|---|---|
| Oracle E-Business Suite 12.2 | Legacy ERP (modules being retired) | PL/SQL, ISG SOAP/REST, Business Events | Bidirectional |
| Oracle Fusion Cloud ERP 25A | Target ERP (modules going live) | REST API, SOAP, FBDI, Business Events | Bidirectional |
| Oracle Integration Cloud Gen 3 | Integration hub | EBS Adapter, ERP Cloud Adapter, Scheduler | Orchestrator |
| Oracle GoldenGate (optional) | Real-time data replication | Change Data Capture | EBS → Fusion |
| Unified Data Warehouse | Consolidated reporting | BIP, OTBI, ODI | Inbound from both |

## API Surfaces & Capabilities

During coexistence, both systems must exchange data in near-real-time for shared entities and in batch mode for reconciliation. OIC orchestrates all cross-system flows. [src1]

| Integration Pattern | OIC Component | Direction | Latency | Volume | Use When |
|---|---|---|---|---|---|
| Event-driven sync | EBS Adapter (Business Events) | EBS → Fusion | Seconds | Low-medium | Master data changes in EBS trigger Fusion updates |
| Scheduled poll | OIC Scheduler + EBS Adapter | EBS → Fusion | Minutes | Medium-high | Batch sync of transactions at intervals |
| REST-to-REST | ERP Cloud Adapter → EBS ISG REST | Fusion → EBS | Seconds | Low | Fusion transactions that need EBS processing |
| FBDI bulk load | OIC File Adapter + ERP integration REST | EBS → Fusion | Hours | High | Initial data loads and periodic reconciliation |
| Business Events | ERP Cloud Adapter (Business Events) | Fusion → EBS | Seconds | Low-medium | Fusion events that trigger EBS processing |
| GoldenGate CDC | Oracle GoldenGate | EBS → Fusion/DW | Sub-second | High | Real-time replication for reporting |

## Rate Limits & Quotas

### Per-Request Limits

| Limit Type | Value | System | Notes |
|---|---|---|---|
| EBS ISG concurrent sessions | 50 (default) | EBS | Configurable; increase for high-volume coexistence [src4] |
| Fusion REST POST max records | 500 | Fusion Cloud | Use FBDI for higher volumes [src3] |
| OIC integration flow timeout | 300 seconds (sync), 24 hours (async) | OIC | Use async for long-running operations [src6] |
| OIC Connectivity Agent connections | 10 concurrent | OIC Agent | Per agent instance; deploy multiple for HA |
| FBDI concurrent imports | 5 | Fusion Cloud | Coordinate scheduling to avoid contention |

### Rolling / Daily Limits

| Limit Type | Value | Window | Notes |
|---|---|---|---|
| OIC message packs | 5,000-50,000/month | Monthly | Each integration execution = 1 message; bidirectional doubles consumption [src6] |
| EBS ISG daily API calls | No hard limit | N/A | Constrained by EBS server capacity |
| Fusion Cloud REST API | Fair-use throttling | Per pod | Shared across all integrations on the pod [src3] |
| GoldenGate trail file size | 10 GB default | Per trail | Configurable; archive old trail files |

## Authentication

| Flow | System | Method | Managed By | Notes |
|---|---|---|---|---|
| EBS inbound | EBS (ISG) | Username/password | OIC Connection | Stored in OIC Secure vault |
| EBS outbound (events) | EBS → OIC | Business Event subscription | OIC EBS Adapter | Agent-based, no separate auth |
| Fusion inbound | Fusion Cloud | OAuth 2.0 JWT Bearer | OIC ERP Cloud Adapter | Automatic token management |
| Fusion outbound (events) | Fusion → OIC | Business Event subscription | OIC ERP Cloud Adapter | Native cloud adapter |
| OIC Connectivity Agent | OIC ↔ EBS network | mTLS + Agent credentials | OIC Agent config | Must allow outbound HTTPS from agent |

### Authentication Gotchas

- EBS ISG services must be deployed and granted to the integration user before OIC EBS Adapter can discover them — this is a multi-step setup process in EBS [src4]
- OIC Connectivity Agent credentials expire and must be refreshed — set up monitoring for agent heartbeat failures [src1]
- If EBS uses Oracle Access Manager (OAM) SSO, the integration user must bypass OAM for API-level access — configure ISG to use direct authentication for the integration user [src4]

## Constraints

- Every shared data entity (customers, suppliers, items, GL accounts) must have exactly one designated source-of-truth system — ambiguity causes data conflicts [src2]
- Cross-system document numbering requires either non-overlapping ranges (e.g., EBS: 1-999999, Fusion: 1000000+) or a cross-reference mapping table maintained by OIC [src5]
- GL period close must be synchronized — if Financials runs in Fusion but Procurement in EBS, AP invoices must flow from EBS to Fusion GL before period close [src2]
- Fusion Cloud quarterly updates cannot be deferred — coexistence integrations must be regression-tested every quarter [src3]
- OIC message pack consumption approximately doubles during coexistence compared to single-system integration [src6]
- Reporting requires data from both systems — implement a unified data warehouse or use FDI (Fusion Data Intelligence) with ODI feeds from EBS [src2]

## Integration Pattern Decision Tree

```
START — Running EBS and Fusion Cloud in coexistence
├── Which modules are in each system?
│   ├── Financials in Fusion, Procurement/SCM in EBS
│   │   ├── AP Invoices → EBS → OIC → Fusion GL (journal entries)
│   │   ├── PO data → EBS → OIC → Fusion (for reporting)
│   │   └── Supplier master → Designate source of truth (usually EBS during this phase)
│   ├── Procurement in Fusion, Financials in EBS
│   │   ├── PO/Invoice → Fusion → OIC → EBS GL (journal entries)
│   │   ├── Supplier master → Designate source of truth (usually Fusion)
│   │   └── Payment processing → Stays in EBS until Financials migrates
│   └── HCM in Fusion Cloud, ERP in EBS
│       ├── Employee master → Fusion HCM → OIC → EBS HR (sync)
│       ├── Expense reports → Fusion → OIC → EBS AP (for payment)
│       └── Payroll → Fusion → OIC → EBS GL (costing entries)
├── What data needs to sync?
│   ├── Master data (customers, suppliers, items)
│   │   ├── Designate source of truth per entity
│   │   ├── Implement OIC flow: source → OIC → target
│   │   └── Maintain cross-reference table for ID mapping
│   ├── Transactional data (POs, invoices, journals)
│   │   ├── One-way flow: source module system → target module system
│   │   └── Use batch (FBDI) for high volume, real-time for low volume
│   └── Reference data (GL accounts, cost centers, currencies)
│       └── Sync from source of truth before go-live; event-driven after
├── Sync frequency?
│   ├── Real-time (< 30 seconds) → OIC event-driven integration
│   ├── Near-real-time (1-15 minutes) → OIC scheduled poll
│   ├── Batch (hourly/daily) → OIC scheduled + FBDI
│   └── On-demand → OIC triggered by user action or API call
└── Conflict resolution?
    ├── Source-of-truth wins → Always overwrite target
    ├── Last-write-wins → Timestamp comparison
    └── Manual review → Queue conflicts for human resolution
```

## Quick Reference

### Coexistence Integration Flows by Module Split

| Module Split | Key Data Flows | Sync Pattern | Source of Truth | Critical Timing |
|---|---|---|---|---|
| Financials in Fusion, Procurement in EBS | AP invoices → GL journals | Batch (hourly) | EBS for suppliers, Fusion for GL | Before period close |
| Procurement in Fusion, Financials in EBS | PO → Invoice → GL | Event-driven + batch | Fusion for suppliers, EBS for GL | Before payment run |
| SCM in EBS, Financials in Fusion | Inventory transactions → GL | Batch (daily) | EBS for items, Fusion for GL | Before inventory close |
| HCM in Fusion, Payroll in EBS | Employee → Payroll → GL costing | Scheduled (daily) | Fusion for employees, EBS for payroll | Before payroll run |
| Full modules in both (parallel run) | All master + transactional data | Bidirectional real-time | Designated per entity | Continuous |
| Projects in Fusion, AP in EBS | Project costs → AP invoices | Event-driven | Fusion for projects, EBS for AP | Before billing cycle |

### Cross-Reference Table Design

| Column | Type | Purpose |
|---|---|---|
| entity_type | VARCHAR(50) | Customer, Supplier, Item, GL Account |
| ebs_id | VARCHAR(100) | EBS internal ID or segment value |
| fusion_id | VARCHAR(100) | Fusion Cloud internal ID |
| sync_status | VARCHAR(20) | SYNCED, PENDING, ERROR, CONFLICT |
| last_synced | TIMESTAMP | Last successful sync timestamp |
| source_system | VARCHAR(10) | EBS or FUSION — which system owns this record |

## Step-by-Step Integration Guide

### 1. Deploy OIC Connectivity Agent for EBS Access

Install the OIC Connectivity Agent on an on-premise VM (or OCI compute) that has network access to both EBS and the internet (outbound HTTPS to OIC). [src1]

```bash
# Download agent installer from OIC console
# → Integrations → Agents → Download → Agent Installer

# Install agent on dedicated VM (Linux)
chmod +x oic_agent_installer.sh
./oic_agent_installer.sh \
  --agent-group-identifier=EBS_AGENT_GROUP \
  --oic-url=https://<oic-instance>.integration.ocp.oraclecloud.com

# Verify agent status
curl -s "https://<oic-url>/ic/api/integration/v1/monitoring/agents" \
  -H "Authorization: Bearer $OIC_TOKEN" | jq '.items[] | {name, status}'
```

**Verify**: Agent status shows `CONNECTED` in OIC Console → Agents page.

### 2. Configure EBS ISG Services for OIC Adapter

Deploy and grant required REST/SOAP services in EBS Integrated SOA Gateway so OIC can discover and invoke them. [src4]

```sql
-- In EBS: Deploy ISG service for Supplier API
-- Navigation: ISG Responsibility → Integration Repository → Search
-- Find: Supplier API → Deploy as REST

-- Grant service to integration user
BEGIN
  fnd_soa_util.grant_service(
    p_service_id     => '<service_id>',
    p_grantee_type   => 'USER',
    p_grantee_key    => 'OIC_INTEGRATION_USER'
  );
END;
/

-- Register Business Events for outbound notifications
-- Navigation: Workflow Administrator → Business Events
-- Events: oracle.apps.ap.supplier.create, oracle.apps.ap.supplier.update
```

**Verify**: OIC EBS Adapter connection test succeeds and service catalog shows deployed services.

### 3. Create OIC Integration Flow for Master Data Sync

Build a scheduled integration in OIC that polls EBS for changed suppliers and syncs to Fusion Cloud. [src1, src6]

```
# OIC Integration Flow: EBS Supplier → Fusion Cloud Supplier
#
# Trigger: OIC Scheduler (every 15 minutes)
# Step 1: Query EBS for suppliers modified since last sync
#   → EBS Adapter: GET /rest/suppliers?modified_after=<timestamp>
# Step 2: For each supplier:
#   → Lookup cross-reference table for existing Fusion ID
#   → If exists: PUT /fscmRestApi/resources/latest/suppliers/<id>
#   → If new: POST /fscmRestApi/resources/latest/suppliers
#   → Update cross-reference table with sync status
# Step 3: Log results to pipeline_log table
```

**Verify**: Create a test supplier in EBS → verify it appears in Fusion Cloud within 15 minutes.

### 4. Implement Cross-Reference ID Mapping

Create and maintain a mapping table that links EBS internal IDs to Fusion Cloud IDs for every shared entity. [src5]

```sql
-- Create cross-reference table (in a separate database or OIC Lookups)
CREATE TABLE erp_xref (
  xref_id        NUMBER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
  entity_type    VARCHAR2(50) NOT NULL,
  ebs_id         VARCHAR2(100) NOT NULL,
  fusion_id      VARCHAR2(100),
  sync_status    VARCHAR2(20) DEFAULT 'PENDING',
  last_synced    TIMESTAMP,
  source_system  VARCHAR2(10) NOT NULL,
  error_message  VARCHAR2(4000),
  CONSTRAINT uq_xref UNIQUE (entity_type, ebs_id)
);

CREATE INDEX idx_xref_sync ON erp_xref(sync_status, entity_type);
```

**Verify**: `SELECT COUNT(*) FROM erp_xref WHERE sync_status = 'SYNCED'` shows records after first sync run.

## Code Examples

### Python: Cross-System Supplier Sync via OIC REST API

```python
# Input:  EBS supplier changes (from ISG REST), Fusion Cloud REST endpoint
# Output: Synced supplier records with cross-reference mapping

import requests
import datetime

EBS_URL = "http://<ebs-host>:<port>/webservices/rest/supplier/v1"
FUSION_URL = "https://<pod>.fa.us2.oraclecloud.com/fscmRestApi/resources/latest"
EBS_AUTH = ("<user>", "<password>")
FUSION_TOKEN = "<oauth_token>"
FUSION_HEADERS = {"Authorization": f"Bearer {FUSION_TOKEN}", "Content-Type": "application/json"}

def sync_suppliers(last_sync_time):
    """Sync changed suppliers from EBS to Fusion Cloud."""
    # Step 1: Get changed suppliers from EBS
    ebs_resp = requests.get(
        f"{EBS_URL}/suppliers",
        params={"modifiedAfter": last_sync_time.isoformat()},
        auth=EBS_AUTH
    )
    ebs_suppliers = ebs_resp.json().get("items", [])

    results = {"synced": 0, "errors": 0, "skipped": 0}
    for supplier in ebs_suppliers:
        ebs_id = supplier["VendorId"]

        # Step 2: Check cross-reference for existing Fusion ID
        fusion_id = lookup_xref("SUPPLIER", ebs_id)

        try:
            if fusion_id:
                # Update existing supplier in Fusion
                resp = requests.patch(
                    f"{FUSION_URL}/suppliers/{fusion_id}",
                    json=map_supplier_fields(supplier),
                    headers=FUSION_HEADERS
                )
            else:
                # Create new supplier in Fusion
                resp = requests.post(
                    f"{FUSION_URL}/suppliers",
                    json=map_supplier_fields(supplier),
                    headers=FUSION_HEADERS
                )
                fusion_id = resp.json().get("SupplierId")
                save_xref("SUPPLIER", ebs_id, fusion_id)

            resp.raise_for_status()
            results["synced"] += 1
        except requests.HTTPError as e:
            results["errors"] += 1
            log_sync_error("SUPPLIER", ebs_id, str(e))

    return results
```

### cURL: Test Cross-System Connectivity

```bash
# Input:  EBS and Fusion credentials
# Output: Confirmation both systems are reachable

# Test EBS ISG REST service
curl -s -w "\nHTTP Status: %{http_code}\n" \
  "http://<ebs-host>:<port>/webservices/rest/supplier/v1/suppliers?limit=1" \
  -u "<user>:<password>"

# Test Fusion Cloud REST API
curl -s -w "\nHTTP Status: %{http_code}\n" \
  "https://<pod>.fa.us2.oraclecloud.com/fscmRestApi/resources/latest/suppliers?limit=1" \
  -H "Authorization: Bearer $FUSION_TOKEN"

# Test OIC Agent status
curl -s "https://<oic-url>/ic/api/integration/v1/monitoring/agents" \
  -H "Authorization: Bearer $OIC_TOKEN" \
  | jq '.items[] | {name: .agentGroupName, status: .status}'
```

## Data Mapping

### Cross-System Entity Mapping

| Entity | EBS Table/View | Fusion Cloud REST Resource | Key Mapping | Conflict Resolution |
|---|---|---|---|---|
| Supplier | AP_SUPPLIERS | /suppliers | VENDOR_ID → SupplierId | Source-of-truth wins |
| Customer | HZ_PARTIES + HZ_CUST_ACCOUNTS | /accounts | CUST_ACCOUNT_ID → PartyId | Source-of-truth wins |
| Item | MTL_SYSTEM_ITEMS_B | /inventoryItems | INVENTORY_ITEM_ID → ItemId | EBS master during transition |
| GL Account | GL_CODE_COMBINATIONS | /ledgerAccounts | CODE_COMBINATION_ID → AccountId | Fusion master for GL |
| Employee | PER_ALL_PEOPLE_F | /workers (HCM) | PERSON_ID → PersonId | HCM source always |
| Cost Center | GL segments | /chartOfAccountsSegments | SEGMENT value | Fusion master |

### Data Type Gotchas

- EBS VENDOR_ID is NUMBER; Fusion SupplierId is also NUMBER but in a different sequence — never assume ID equivalence across systems [src5]
- EBS stores multi-org data with ORG_ID context; Fusion uses Business Unit (BU) — map ORG_ID to BU before sync [src2]
- EBS date columns use database timezone (typically server-local); Fusion REST API returns UTC — convert explicitly in OIC mapping [src3]
- EBS lookup values (e.g., PAYMENT_METHOD_LOOKUP_CODE) may not match Fusion Cloud seed lookup values — maintain a lookup translation table in OIC [src2]

## Error Handling & Failure Points

### Common Error Codes

| Code | System | Meaning | Cause | Resolution |
|---|---|---|---|---|
| OIC-CONN-AGENT-001 | OIC | Agent unreachable | Network or agent VM down | Restart agent; check firewall rules |
| 401 | Fusion | OAuth token expired | Token lifetime exceeded (3600s default) | OIC auto-refreshes; check if IDCS app is active |
| ISG-AUTH-FAIL | EBS | ISG authentication failure | Password expired or user locked | Reset integration user password in EBS |
| DUPLICATE_KEY | Fusion | Record already exists | ID conflict in cross-reference | Check xref table; implement upsert logic |
| OIC-TIMEOUT | OIC | Integration flow timeout | Long-running operation exceeded 300s sync limit | Switch to async pattern |
| JBO-25013 | Fusion | Row lock contention | Concurrent updates from multiple sources | Implement queue + serial processing for same record |

### Failure Points in Production

- **OIC Agent VM restart loses in-flight messages**: If the Connectivity Agent VM is restarted during active processing, messages in the agent queue are lost. Fix: `Implement idempotent flows with checkpoint tracking; agent HA with 2+ instances`. [src1]
- **GL period close timing mismatch**: If EBS AP closes before Fusion GL has received all journal entries, the period will not balance. Fix: `Implement a pre-close reconciliation job that verifies all EBS journals have been received in Fusion before allowing period close`. [src2]
- **Cross-reference table drift**: Over time, xref entries become stale as records are deleted or merged in one system but not the other. Fix: `Run monthly reconciliation job comparing xref table against both source systems; flag orphaned entries`. [src5]
- **Fusion quarterly update breaks OIC flow**: A new required field added in Fusion 25A causes all supplier sync flows to fail with validation errors. Fix: `Test all coexistence flows in Fusion Preview environment before each quarterly update; maintain a regression test suite`. [src3]

## Anti-Patterns

### Wrong: Direct database-to-database replication without transformation

```
# BAD — Copying EBS tables directly to Fusion Cloud database
# Fusion Cloud has no direct DB access; even if you could access it,
# the data model is completely different
Oracle GoldenGate: EBS.AP_SUPPLIERS → Fusion.POZ_SUPPLIERS
# This will fail — table structures are incompatible
```

### Correct: API-mediated synchronization through OIC

```
# GOOD — Use OIC to transform and sync via APIs
EBS (ISG REST) → OIC (Transform + Map) → Fusion (REST API)
# OIC handles:
# - Field mapping (VENDOR_NAME → SupplierName)
# - ID cross-referencing
# - Error handling and retry
# - Logging and monitoring
```

### Wrong: Allowing both systems to generate overlapping document numbers

```
# BAD — Both systems use same PO number sequence
# EBS: PO-2026-001, PO-2026-002, PO-2026-003
# Fusion: PO-2026-001, PO-2026-002 (DUPLICATE!)
# This creates reconciliation nightmares and audit issues
```

### Correct: Non-overlapping number ranges or prefixed sequences

```
# GOOD — Implement non-overlapping number ranges
# EBS: PO-E-000001 to PO-E-999999 (prefix E for EBS)
# Fusion: PO-F-000001 to PO-F-999999 (prefix F for Fusion)
# Or: EBS uses 1-999999, Fusion starts at 1000000+
# Configure in Fusion: Setup → Document Sequences
```

### Wrong: No source-of-truth designation for shared entities

```
# BAD — Both systems accept supplier updates independently
# User updates supplier address in EBS
# Another user updates same supplier address in Fusion
# OIC sync runs and overwrites one change with the other
# Result: Data loss with no audit trail
```

### Correct: Designate single source of truth per entity

```
# GOOD — Clear ownership rules
# Rule: Suppliers are mastered in EBS until Procurement module migrates
# EBS: Full CRUD on suppliers (source of truth)
# Fusion: Read-only view of suppliers (synced from EBS)
# OIC: One-way sync EBS → Fusion only
# After Procurement migrates: reverse ownership to Fusion
```

## Common Pitfalls

- **Not planning for OIC message consumption**: Bidirectional coexistence flows consume 2x the OIC message packs compared to single-system integration — monitor consumption monthly and upgrade message packs before hitting limits. Fix: `Aggregate batch transactions instead of syncing individual records to reduce message count`. [src6]
- **Ignoring timezone differences in cross-system reconciliation**: EBS and Fusion Cloud may report the same transaction with different timestamps due to timezone handling differences. Fix: `Normalize all timestamps to UTC in the cross-reference table and reconciliation reports`. [src3]
- **Parallel period close without synchronization**: Running month-end close in both systems without coordinating causes subledger-to-GL discrepancies. Fix: `Implement a close checklist: verify all cross-system journals are posted, run reconciliation, then close periods in sequence`. [src2]
- **Not testing coexistence flows with Fusion quarterly updates**: Oracle's mandatory quarterly updates can introduce new required fields, changed validations, or deprecated endpoints. Fix: `Test all OIC integration flows in the Fusion Preview environment 4 weeks before each update`. [src3]
- **Single-point-of-failure OIC Agent**: Running a single Connectivity Agent instance means any agent downtime stops all EBS-to-cloud data flow. Fix: `Deploy 2+ agent instances in an agent group for HA; monitor agent heartbeat`. [src1]

## Diagnostic Commands

```bash
# Check OIC Agent status
curl -s "https://<oic-url>/ic/api/integration/v1/monitoring/agents" \
  -H "Authorization: Bearer $OIC_TOKEN" | jq '.items[] | {name: .agentGroupName, status}'
# Expected: status = "CONNECTED"

# Check OIC integration flow execution history
curl -s "https://<oic-url>/ic/api/integration/v1/monitoring/instances?status=FAILED&limit=10" \
  -H "Authorization: Bearer $OIC_TOKEN" | jq '.items[] | {id, flowName, status, startTime}'

# Check EBS ISG service deployment status
# In EBS: SELECT * FROM fnd_soa_services WHERE status = 'DEPLOYED';

# Verify cross-reference table health
# SELECT entity_type, sync_status, COUNT(*) FROM erp_xref GROUP BY entity_type, sync_status;

# Check Fusion Cloud REST API for recently synced suppliers
curl -s "https://<pod>.fa.us2.oraclecloud.com/fscmRestApi/resources/latest/suppliers?\
q=LastUpdateDate>$(date -u -d '1 hour ago' '+%Y-%m-%dT%H:%M:%S')" \
  -H "Authorization: Bearer $FUSION_TOKEN" | jq '.items | length'
```

## Version History & Compatibility

| Component | Version | Status | Coexistence Impact |
|---|---|---|---|
| OIC Generation 3 | Current | GA | Recommended; Gen 2 still supported but fewer features |
| OIC EBS Adapter | 24.10 | Current | Supports EBS 12.2 ISG REST + SOAP + Business Events |
| OIC ERP Cloud Adapter | 24.10 | Current | Supports Fusion 25A REST + SOAP + Business Events |
| EBS 12.2 ISG | RUP 12.2.12+ | Supported | Latest RUP recommended for best REST service coverage |
| Fusion Cloud 25A | 2025-02 | Current | New business events for procurement objects |

### Deprecation Policy

OIC adapters are updated quarterly in alignment with Fusion Cloud releases. Oracle maintains backward compatibility for adapter versions but recommends staying on the latest version. EBS ISG services are not deprecated as long as EBS 12.2 is in Premier Support (through at least 2035). [src4, src6]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Running EBS and Fusion Cloud simultaneously during phased migration | Planning the initial migration strategy | oracle-ebs-to-fusion-migration/2026 |
| Need real-time data sync between EBS and Fusion | One-time data migration (not ongoing sync) | FBDI bulk load via oracle-ebs-to-fusion-migration/2026 |
| Module-by-module cutover spanning 6-24 months | Big-bang cutover with no coexistence period | Standard migration guide |
| Cross-system reporting during transition | Fusion-only environment post-migration | Fusion Cloud REST API reference |

## Important Caveats

- Coexistence is inherently temporary — every integration built for coexistence will be decommissioned when the migration completes; invest in good documentation for teardown
- OIC licensing costs during coexistence can be significant — budget for 2x message pack consumption compared to steady-state
- Fusion Cloud quarterly updates are mandatory and may break coexistence flows — build regression testing into the quarterly update cycle
- Cross-system reconciliation is labor-intensive — budget dedicated resources for monthly reconciliation during the coexistence period
- The longer coexistence runs, the more complex and costly it becomes — set hard deadlines for completing the full migration

## Related Units

- [Oracle EBS to Fusion Cloud Migration](/business/erp-integration/oracle-ebs-to-fusion-migration/2026) — Prerequisite: migration planning and API mapping
- [Oracle Redwood UI Impact on Integrations](/business/erp-integration/oracle-redwood-ui-impact-integrations/2026) — UI changes during coexistence period
- [Oracle Retail Suite Upgrade Planning](/business/erp-integration/oracle-retail-suite-upgrade-planning/2026) — Retail-specific coexistence considerations