---
# === IDENTITY ===
id: business/erp-integration/oracle-ebs-to-fusion-migration/2026
canonical_question: "How do you migrate from Oracle E-Business Suite to Fusion Cloud - API changes, data, coexistence?"
aliases:
  - "Oracle EBS to Fusion Cloud migration guide"
  - "EBS to Oracle Cloud ERP API differences"
  - "Oracle E-Business Suite to Fusion migration technical plan"
  - "EBS to Fusion data migration and coexistence strategy"
entity_type: erp_integration
domain: business > erp-integration > oracle-ebs-to-fusion-migration
region: global
jurisdiction: global
temporal_scope: 2024-2027

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

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

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "25A — new REST API endpoints replaced legacy SOAP for several Financials objects"
  next_review: 2026-09-05
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "No direct SQL or PL/SQL access to Fusion Cloud database — all data access via REST, SOAP, or FBDI"
  - "FBDI ZIP file max 250 MB; individual files within ZIP max 1 GB"
  - "REST API POST operations limited to 500 records per request"
  - "Maximum 5 concurrent FBDI import activities at once"
  - "EBS Integrated SOA Gateway (ISG) must be configured before OIC EBS Adapter works"
  - "EBS 12.2 Premier Support extended through at least 2035 — no forced migration deadline"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "Already running Fusion Cloud and need coexistence patterns only"
    use_instead: "business/erp-integration/oracle-erp-cloud-coexistence-patterns/2026"
  - condition: "Need Oracle Retail Suite upgrade guidance specifically"
    use_instead: "business/erp-integration/oracle-retail-suite-upgrade-planning/2026"
  - condition: "Need Redwood UI migration impact assessment"
    use_instead: "business/erp-integration/oracle-redwood-ui-impact-integrations/2026"

# === AGENT HINTS ===
inputs_needed:
  - key: migration_approach
    question: "Which migration approach are you considering?"
    type: choice
    options:
      - "big-bang reimplementation (clean start)"
      - "phased coexistence (module-by-module)"
      - "lift-and-shift to OCI first, then reimplement"
  - key: data_volume
    question: "What is your approximate data volume for migration?"
    type: choice
    options:
      - "< 1 million records total"
      - "1-50 million records"
      - "> 50 million records"
  - key: customization_level
    question: "How customized is your EBS environment?"
    type: choice
    options:
      - "lightly customized (< 50 custom objects)"
      - "moderately customized (50-500 custom objects)"
      - "heavily customized (> 500 custom objects or deep PL/SQL)"

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

# === RELATED UNITS ===
related_kos:
  depends_on: []
  related_to:
    - id: "business/erp-integration/oracle-erp-cloud-coexistence-patterns/2026"
      label: "Coexistence patterns for running EBS and Fusion simultaneously"
  solves: []
  alternative_to: []
  often_confused_with:
    - id: "business/erp-integration/oracle-redwood-ui-impact-integrations/2026"
      label: "Redwood UI migration — different scope from full ERP migration"

# === SOURCES ===
sources:
  - id: src1
    title: "Oracle Fusion Cloud ERP Integrations Challenges, Guidelines, Patterns 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: src2
    title: "Data Import Options and Guidelines for Fusion Applications Suite"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/data-import-options-and-guidelines-for-fusion-applications-suite
    type: technical_blog
    published: 2024-06-20
    reliability: authoritative
  - id: src3
    title: "On-Premises ERP to Oracle Cloud ERP Migration"
    author: Oracle
    url: https://www.oracle.com/erp/migrate-to-cloud/
    type: official_docs
    published: 2025-01-01
    reliability: authoritative
  - id: src4
    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: src5
    title: "Complete Guide to Migrating Data from Oracle E-Business Suite to Oracle Fusion Cloud ERP"
    author: Datafusing
    url: https://www.datafusing.com/migrating-data-from-oracle-e-business-suite-to-oracle-fusion/
    type: technical_blog
    published: 2025-03-10
    reliability: high
  - id: src6
    title: "EBS 12.2 Premier Support Extended Through At Least 2035"
    author: Oracle
    url: https://blogs.oracle.com/ebstech/ebs-122-premier-support-extended-through-at-least-2035
    type: vendor_release_notes
    published: 2024-09-01
    reliability: authoritative
---

# Oracle EBS to Fusion Cloud Migration: API Changes, Data, and Coexistence

## TL;DR

- **Bottom line**: Migrating from Oracle EBS to Fusion Cloud requires replacing PL/SQL-based integrations with REST APIs, FBDI for bulk data, and Oracle Integration Cloud (OIC) for orchestration — there is no in-place upgrade path.
- **Key limit**: Fusion Cloud has no direct database access; all data operations must go through REST (max 500 records/POST), SOAP, or FBDI (max 250 MB ZIP, max 5 concurrent imports).
- **Watch out for**: Custom PL/SQL procedures, open interface tables, and concurrent programs have no direct equivalents in Fusion — each must be redesigned using REST APIs, FBDI templates, or ESS scheduled processes.
- **Best for**: Organizations on EBS 12.2 planning a phased or big-bang move to Oracle Cloud ERP with 12-36 month timeline.
- **Authentication**: Fusion Cloud uses OAuth 2.0 (JWT bearer for server-to-server) or SAML/IDCS; EBS ISG uses username/password or token-based auth through SOA Gateway.

## System Profile

This card covers the technical migration path from Oracle E-Business Suite 12.2 (on-premise, all editions) to Oracle Fusion Cloud ERP (Release 24B/25A). It addresses the API surface changes, data migration methods, integration middleware options, and coexistence architecture during the transition period. This card does not cover Oracle Retail Suite upgrades or Redwood UI migration — see related units for those topics. [src3]

| System | Role | API Surface | Direction |
|---|---|---|---|
| Oracle E-Business Suite 12.2 | Source ERP (on-premise) | PL/SQL, SOAP/REST via ISG, Open Interface Tables | Outbound |
| Oracle Fusion Cloud ERP 25A | Target ERP (cloud) | REST API, SOAP, FBDI, ADFdi | Inbound |
| Oracle Integration Cloud (OIC) | Integration middleware | EBS Adapter, ERP Cloud Adapter | Orchestrator |
| Oracle Data Integrator (ODI) | ETL for bulk migration | Batch file processing | Orchestrator |

## API Surfaces & Capabilities

The fundamental API shift from EBS to Fusion Cloud is the elimination of direct database access. In EBS, integrations commonly used PL/SQL procedures, open interface tables, and concurrent programs. None of these are available in Fusion Cloud. [src1]

| API Surface | EBS Equivalent | Fusion Cloud Method | Best For | Max Records/Request | Real-time? | Bulk? |
|---|---|---|---|---|---|---|
| REST API | ISG REST Services | Native REST endpoints | Real-time CRUD, < 500 records | 500 per POST | Yes | No |
| SOAP Web Services | ISG SOAP Services | ERP Cloud SOAP services | Complex operations, metadata | Varies | Yes | No |
| FBDI (File-Based Data Import) | Open Interface Tables + Concurrent Programs | Excel/CSV templates uploaded to UCM | Bulk data loading, > 500 records | 100,000 per import | No | Yes |
| ADFdi (ADF Desktop Integration) | Spreadsheet-based entry | Excel add-in for direct data entry | Manual data entry corrections | N/A | Semi | No |
| BIP Reports | Concurrent Programs / XML Publisher | BI Publisher for extracts | Data extraction, reporting | N/A | No | Yes |
| ESS Jobs | Concurrent Manager | Enterprise Scheduler Service | Scheduled processing | N/A | No | Yes |

## Rate Limits & Quotas

### Per-Request Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Max records per REST POST | 500 | REST API | Use FBDI for higher volumes [src1] |
| Max FBDI ZIP file size | 250 MB | FBDI uploads | Individual files within ZIP can be up to 1 GB [src2] |
| Max concurrent FBDI imports | 5 | FBDI import jobs | Queue additional imports [src2] |
| Max FBDI records per import | 100,000 | Single FBDI import batch | Split larger datasets [src2] |
| UCM file upload limit | 2 GB | WebCenter Content (UCM) | For FBDI file staging |

### Rolling / Daily Limits

| Limit Type | Value | Window | Notes |
|---|---|---|---|
| REST API calls | Fair-use throttling | Per pod | No hard daily cap; Oracle throttles based on pod load [src1] |
| ESS concurrent jobs | Pod-dependent (typically 8-16) | Per pod | Shared across all scheduled processes |
| FBDI imports per day | No hard limit | Per pod | Constrained by ESS job slots |
| OIC message packs | License-dependent (5K-50K/month) | Monthly | Each integration flow execution consumes messages |

## Authentication

| Flow | EBS Method | Fusion Cloud Method | Notes |
|---|---|---|---|
| Server-to-server | ISG username/password | OAuth 2.0 JWT Bearer via IDCS | Recommended for all integrations [src1] |
| User-context | SSO (Oracle Access Manager) | SAML 2.0 / IDCS Federation | For UI-based access |
| OIC Adapter | EBS ISG + Connectivity Agent | ERP Cloud Adapter (native) | Agent required for on-premise EBS [src4] |
| Basic Auth | Supported in ISG | Supported but not recommended | Use OAuth 2.0 instead |

### Authentication Gotchas

- EBS ISG must have SOA Gateway configured and specific services deployed before OIC EBS Adapter can connect — this is a common blocker in early migration phases [src4]
- Fusion Cloud OAuth tokens are scoped to the integration user's role — ensure the integration user has all required data roles (not just responsibility-based access like EBS) [src1]
- OIC Connectivity Agent must run on an on-premise VM or OCI compute to bridge EBS with cloud — network firewall rules must allow outbound HTTPS from agent to OIC [src4]
- IDCS app registration is required for JWT bearer flow — self-signed certificates work in development but CA-signed certificates are needed for production [src1]

## Constraints

- No direct SQL access to Fusion Cloud database — all PL/SQL procedures, open interface tables, and custom SQL must be redesigned [src1]
- FBDI templates are fixed and cannot be modified — you must map your data to Oracle's predefined column structure [src2]
- Concurrent Programs do not exist in Fusion Cloud — replace with ESS scheduled processes or BIP reports [src1]
- Custom Forms (Oracle Forms) have no equivalent — redesign using Visual Builder Cloud Service (VBCS) or REST API integrations [src1]
- Data migration requires full data cleansing before import — Fusion Cloud enforces stricter validation than EBS open interface tables [src5]
- EBS flexfield structures may not map 1:1 to Fusion Cloud extensible flexfields — requires redesign [src1]

## Integration Pattern Decision Tree

```
START — Migrating from Oracle EBS to Fusion Cloud
├── What needs to migrate?
│   ├── Master Data (customers, suppliers, items, COA)
│   │   ├── Volume < 100K records?
│   │   │   ├── YES → FBDI (single batch per entity)
│   │   │   └── NO → FBDI with chunking (split into 100K batches)
│   │   └── Need ongoing sync during coexistence?
│   │       ├── YES → OIC with EBS Adapter (event-driven or scheduled)
│   │       └── NO → One-time FBDI load
│   ├── Open Transactions (POs, invoices, journals)
│   │   ├── Convert in-flight transactions?
│   │   │   ├── YES → Complete in EBS first, then migrate as history
│   │   │   └── NO → Close in EBS, re-enter critical ones in Fusion
│   │   └── Historical data?
│   │       ├── YES → FBDI for balances, BIP extract for detail
│   │       └── NO → Opening balances only via FBDI
│   ├── Integrations (with external systems)
│   │   ├── EBS PL/SQL interface?
│   │   │   └── Redesign → Fusion REST API + OIC orchestration
│   │   ├── EBS Open Interface Tables?
│   │   │   └── Redesign → FBDI or REST API
│   │   ├── Concurrent Programs?
│   │   │   └── Redesign → ESS Jobs or BIP scheduled reports
│   │   └── Custom Forms?
│   │       └── Redesign → VBCS pages or REST API
│   └── Custom Reports
│       └── Redesign → OTBI (transactional), BIP (pixel-perfect), FDI (analytics)
├── Coexistence needed?
│   ├── YES → See oracle-erp-cloud-coexistence-patterns/2026
│   └── NO → Big-bang cutover with parallel run
└── Timeline?
    ├── < 12 months → Focus on core modules, defer customizations
    ├── 12-24 months → Standard phased approach
    └── > 24 months → Module-by-module coexistence
```

## Quick Reference

### EBS to Fusion Cloud API Mapping

| EBS Component | Fusion Cloud Replacement | Migration Effort | Notes |
|---|---|---|---|
| PL/SQL API (direct DB) | REST API | High | Complete rewrite required |
| Open Interface Tables | FBDI templates | Medium | Map columns to FBDI format |
| Concurrent Programs | ESS Scheduled Processes | Medium | Rewrite in ESS or BIP |
| Oracle Forms | VBCS Pages | High | UI redesign from scratch |
| Oracle Reports | BIP Reports / OTBI | Medium | Template redesign |
| Discoverer Reports | OTBI / FDI Analytics | Medium | Query logic redesign |
| Workflow (AME/WF) | BPM / Approval Rules | Medium | Approval chain redesign |
| Alerts | Business Events / Notifications | Low-Medium | Event subscription model |
| XML Gateway (EDI) | B2B Integration / OIC | Medium | EDI partner remapping |
| ISG SOAP Services | Fusion REST API | Medium | Protocol + payload change |
| DFFs/KFFs | Extensible Flexfields (EFF) | High | Structure may differ |
| Custom Tables | Extension tables or REST APIs | High | No custom schema in Fusion |

## Step-by-Step Integration Guide

### 1. Assess EBS Environment and Catalog Integrations

Document all active integrations, customizations, and data volumes in the current EBS environment. Create an integration inventory with API surface, direction, frequency, and volume for each integration point. [src5]

```bash
# In EBS: Query active integrations from ISG
SELECT service_name, service_type, direction, status
FROM fnd_soa_services
WHERE status = 'DEPLOYED'
ORDER BY service_type;

# Count custom PL/SQL packages
SELECT COUNT(*) as custom_packages
FROM all_objects
WHERE object_type = 'PACKAGE'
AND owner NOT IN ('APPS','SYS','SYSTEM')
AND status = 'VALID';
```

**Verify**: Review inventory spreadsheet — ensure every integration has a Fusion Cloud replacement method assigned.

### 2. Configure Fusion Cloud Integration User and OAuth

Create a dedicated integration user in Fusion Cloud with appropriate data roles, then set up IDCS OAuth application for server-to-server authentication. [src1]

```bash
# Test OAuth token acquisition for Fusion Cloud
curl -X POST \
  "https://<idcs-url>/oauth2/v1/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials&scope=urn:opc:resource:consumer::all" \
  -u "<client_id>:<client_secret>"

# Expected response:
# {"access_token":"eyJ...","token_type":"Bearer","expires_in":3600}
```

**Verify**: Use the token to call a simple REST endpoint — `GET /fscmRestApi/resources/latest/ledgers` should return your chart of accounts.

### 3. Migrate Master Data via FBDI

Extract master data from EBS, transform to FBDI template format, upload to Fusion UCM, and trigger import. [src2]

```python
# Input:  EBS supplier extract (CSV), FBDI template mapping
# Output: Fusion Cloud import job ID and status

import requests
import base64
import time

FUSION_URL = "https://<pod>.fa.us2.oraclecloud.com"
TOKEN = "<oauth_access_token>"
HEADERS = {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}

# Step 1: Upload FBDI ZIP to UCM
with open("SupplierImport.zip", "rb") as f:
    content = base64.b64encode(f.read()).decode()

upload_payload = {
    "OperationName": "uploadFileToUCM",
    "DocumentContent": content,
    "DocumentAccount": "fin$/supplier$/import$",
    "FileName": "SupplierImport.zip",
    "ContentType": "application/zip"
}

resp = requests.post(
    f"{FUSION_URL}/fscmRestApi/resources/latest/erpintegrations",
    json=upload_payload, headers=HEADERS
)
doc_id = resp.json()["DocumentId"]

# Step 2: Trigger import process
import_payload = {
    "OperationName": "importBulkData",
    "DocumentId": doc_id,
    "JobName": "/oracle/apps/ess/procurement/poz/supplier/SupplierImportJob"
}

resp = requests.post(
    f"{FUSION_URL}/fscmRestApi/resources/latest/erpintegrations",
    json=import_payload, headers=HEADERS
)
request_id = resp.json()["ReqstId"]
print(f"Import job submitted: {request_id}")
```

**Verify**: `GET /fscmRestApi/resources/latest/erpintegrations?finder=ESSJobStatusRF;requestId={request_id}` — expected: `"RequestStatus":"SUCCEEDED"`

### 4. Set Up OIC for Ongoing Coexistence Sync

Configure Oracle Integration Cloud with EBS Adapter (on-premise via connectivity agent) and ERP Cloud Adapter for bidirectional data flow during coexistence period. [src4]

```
# OIC Integration Flow Architecture:
#
# EBS (on-premise)
#   → Connectivity Agent (on-premise VM)
#     → OIC (cloud)
#       → Fusion Cloud ERP (cloud)
#
# Trigger options:
# - EBS Business Event → OIC EBS Adapter (event-driven)
# - OIC Scheduler → Poll EBS tables (scheduled)
# - Fusion Business Event → OIC ERP Adapter → Write to EBS via ISG
```

**Verify**: Test end-to-end flow with a single supplier record — verify record appears in both systems within SLA window.

## Code Examples

### Python: Bulk Supplier Migration via FBDI

```python
# Input:  EBS supplier extract (Oracle DB query result as CSV)
# Output: FBDI-formatted ZIP ready for Fusion import

import csv
import zipfile
import io

def transform_ebs_to_fbdi(ebs_csv_path, fbdi_output_path):
    """Transform EBS supplier extract to Fusion FBDI template format."""

    # FBDI column mapping: EBS column -> Fusion FBDI column
    COLUMN_MAP = {
        "VENDOR_NAME": "Supplier",
        "VENDOR_TYPE_LOOKUP_CODE": "SupplierType",
        "SEGMENT1": "SupplierNumber",
        "TAX_REFERENCE": "TaxRegistrationNumber",
        "PAYMENT_METHOD_LOOKUP_CODE": "PaymentMethod",
    }

    rows = []
    with open(ebs_csv_path, "r") as f:
        reader = csv.DictReader(f)
        for row in reader:
            fbdi_row = {
                fbdi_col: row.get(ebs_col, "")
                for ebs_col, fbdi_col in COLUMN_MAP.items()
            }
            rows.append(fbdi_row)

    # Write FBDI CSV
    buf = io.StringIO()
    writer = csv.DictWriter(buf, fieldnames=list(COLUMN_MAP.values()))
    writer.writeheader()
    writer.writerows(rows)

    # Package as ZIP (required by FBDI)
    with zipfile.ZipFile(fbdi_output_path, "w", zipfile.ZIP_DEFLATED) as zf:
        zf.writestr("PozsupplierInt.csv", buf.getvalue())

    print(f"Created FBDI ZIP with {len(rows)} suppliers")
    return len(rows)
```

### cURL: Test Fusion Cloud REST API Connectivity

```bash
# Input:  OAuth token, Fusion Cloud pod URL
# Output: List of business units confirming API access

# Get OAuth token
TOKEN=$(curl -s -X POST \
  "https://<idcs-url>/oauth2/v1/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials&scope=urn:opc:resource:consumer::all" \
  -u "<client_id>:<client_secret>" | jq -r '.access_token')

# Test REST API - list business units
curl -s -X GET \
  "https://<pod>.fa.us2.oraclecloud.com/fscmRestApi/resources/latest/businessUnits" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" | jq '.items[].BusinessUnitName'
```

## Data Mapping

### Field Mapping Reference (Suppliers)

| EBS Field | Fusion Cloud Field | Type | Transform | Gotcha |
|---|---|---|---|---|
| AP_SUPPLIERS.VENDOR_NAME | Supplier.SupplierName | String | Direct | Max 360 chars in Fusion (was 240 in EBS) |
| AP_SUPPLIERS.SEGMENT1 | Supplier.SupplierNumber | String | Direct | Must be unique; auto-generation available in Fusion |
| AP_SUPPLIERS.VENDOR_TYPE_LOOKUP_CODE | Supplier.SupplierType | String | Lookup remap | EBS lookup values may not match Fusion seed data |
| AP_SUPPLIER_SITES_ALL.VENDOR_SITE_CODE | SupplierAddress.AddressName | String | Direct | One-to-many relationship differs |
| AP_SUPPLIER_SITES_ALL.PAY_GROUP_LOOKUP_CODE | SupplierSite.PaymentGroup | String | Lookup remap | Requires payment setup in Fusion first |
| PO_VENDOR_CONTACTS.FIRST_NAME | SupplierContact.FirstName | String | Direct | Contact model restructured in Fusion |

### Data Type Gotchas

- EBS stores amounts in the ledger currency with explicit exchange rates; Fusion Cloud uses a multi-currency architecture where exchange rates are managed centrally — ensure rate types are mapped [src1]
- EBS flexfield segment values must be mapped to Fusion Cloud extensible flexfield contexts — the structure is fundamentally different [src1]
- EBS date fields store in database server timezone; Fusion Cloud REST API returns dates in UTC — always convert explicitly [src2]
- EBS concurrent request IDs have no equivalent in Fusion — use ESS request IDs instead, with different numbering sequences [src1]

## Error Handling & Failure Points

### Common Error Codes

| Code | Meaning | Cause | Resolution |
|---|---|---|---|
| JBO-25013 | Too many objects locked | Concurrent updates to same record | Serialize updates; implement retry with backoff |
| FND-0 | Import job failed | FBDI data validation error | Check ESS job output for row-level errors |
| 403 Forbidden | Insufficient privileges | Integration user missing data role | Add required Fusion data role (not job role) |
| 401 Unauthorized | Token expired or invalid | OAuth token lifetime exceeded | Refresh token before each batch; typical lifetime 3600s |
| ADFBC-BC4059 | Duplicate key violation | Record already exists in Fusion | Implement upsert logic; check before insert |
| ORA-20100 | FBDI validation failure | Data format mismatch with template | Validate data against FBDI template columns before upload |

### Failure Points in Production

- **FBDI partial success is silent**: FBDI imports may succeed at the job level but reject individual rows — always check the ESS output file for row-level errors, not just the job status. Fix: `Download error report from ESS job output attachment`. [src2]
- **EBS sequence gaps break Fusion import**: If EBS uses database sequences for document numbering (PO numbers, invoice numbers), gaps in sequences after migration cause confusion. Fix: `Reset Fusion Cloud document sequences to start after the max EBS value + buffer`. [src5]
- **OIC Connectivity Agent disconnects**: The on-premise agent loses connection during network maintenance, causing integration queue backlog. Fix: `Deploy agent in HA mode with 2+ instances; monitor agent heartbeat`. [src4]
- **Character encoding mismatch**: EBS databases often use WE8MSWIN1252; Fusion Cloud uses AL32UTF8 — special characters corrupt during migration. Fix: `Convert all data to UTF-8 before FBDI template generation`. [src5]

## Anti-Patterns

### Wrong: Using REST API for bulk data migration

```python
# BAD — REST API limited to 500 records per POST, extremely slow for bulk loads
for supplier in all_suppliers:  # 50,000 suppliers
    requests.post(f"{FUSION_URL}/fscmRestApi/resources/latest/suppliers",
                  json=supplier, headers=headers)
    # This will take 50,000 API calls and hours to complete
```

### Correct: Use FBDI for bulk data, REST for real-time only

```python
# GOOD — FBDI handles up to 100,000 records per import batch
# Package all 50,000 suppliers in a single FBDI ZIP
create_fbdi_zip(all_suppliers, "SupplierImport.zip")  # Single file
upload_and_import(zip_path="SupplierImport.zip")        # Single import job
# Completes in minutes instead of hours
```

### Wrong: Replicating EBS PL/SQL logic in Fusion Cloud

```sql
-- BAD — Trying to write PL/SQL in Fusion Cloud (impossible)
-- There is NO direct database access in Fusion Cloud
BEGIN
  INSERT INTO po_headers_interface (...) VALUES (...);
  COMMIT;
END;
-- This approach does not work. Period.
```

### Correct: Use Fusion Cloud REST API or FBDI

```python
# GOOD — Use REST API for real-time PO creation
po_payload = {
    "OrderNumber": "PO-2026-001",
    "ProcurementBU": "US Operations",
    "Supplier": "Acme Corp",
    "lines": [{"LineNumber": 1, "ItemDescription": "Widget A", "Quantity": 100}]
}
requests.post(f"{FUSION_URL}/fscmRestApi/resources/latest/purchaseOrders",
              json=po_payload, headers=headers)
```

### Wrong: Big-bang migration without data cleansing

```
# BAD — Migrating all EBS data as-is to Fusion Cloud
# EBS environments often have:
# - Duplicate suppliers (50K+ in large orgs)
# - Orphaned transactions
# - Inactive items with no activity in 5+ years
# Fusion Cloud will reject dirty data or create downstream issues
```

### Correct: Cleanse data before migration, migrate only active records

```python
# GOOD — Extract only active, cleansed data
SELECT * FROM ap_suppliers
WHERE end_date_active IS NULL        -- Active only
  AND vendor_name IS NOT NULL         -- No blanks
  AND creation_date > ADD_MONTHS(SYSDATE, -60)  -- Last 5 years
GROUP BY vendor_name                  -- Deduplicate
```

## Common Pitfalls

- **Underestimating integration redesign effort**: Every EBS PL/SQL-based integration must be completely redesigned for Fusion Cloud — there is no automated conversion tool. Budget 40-60% of total migration effort for integration work. Fix: `Catalog every integration point first; estimate 2-4 weeks per complex integration`. [src1]
- **Ignoring FBDI template versioning**: FBDI templates change with each Fusion Cloud quarterly update — a template that worked in 24B may have new required columns in 25A. Fix: `Always download fresh FBDI templates from the target environment before each migration run`. [src2]
- **Not testing with production data volumes**: FBDI imports that work with 1,000 records in test may fail or timeout with 500,000 records in production. Fix: `Test with production-scale data volumes in a non-production Fusion pod`. [src2]
- **Forgetting coexistence data sync**: During phased migration, data created in one system must flow to the other — this requires OIC integration flows that may not have been planned. Fix: `Design coexistence integration flows before the first module goes live in Fusion`. [src4]
- **Assuming same security model**: EBS uses responsibilities; Fusion Cloud uses roles, data roles, and data security policies — the security model is fundamentally different and requires redesign. Fix: `Map EBS responsibilities to Fusion roles early; expect 30-50% of roles to need custom creation`. [src5]

## Diagnostic Commands

```bash
# Check Fusion Cloud REST API availability
curl -s -o /dev/null -w "%{http_code}" \
  "https://<pod>.fa.us2.oraclecloud.com/fscmRestApi/resources/latest/" \
  -H "Authorization: Bearer $TOKEN"
# Expected: 200

# Check FBDI import job status
curl -s "https://<pod>.fa.us2.oraclecloud.com/fscmRestApi/resources/latest/erpintegrations?finder=ESSJobStatusRF;requestId=<REQ_ID>" \
  -H "Authorization: Bearer $TOKEN" | jq '.items[0].RequestStatus'
# Expected: "SUCCEEDED" or "ERROR"

# Test EBS ISG service availability (for OIC connectivity)
curl -s "http://<ebs-host>:<port>/webservices/rest/<service_name>/" \
  -u "<username>:<password>"
# Expected: 200 with service description

# Verify OIC Agent connectivity
# Check OIC console → Agents page → Agent status should show "Connected"
# Or via OIC REST API:
curl -s "https://<oic-url>/ic/api/integration/v1/monitoring/agents" \
  -H "Authorization: Bearer $OIC_TOKEN" | jq '.items[].status'
# Expected: "CONNECTED"
```

## Version History & Compatibility

| Fusion Cloud Release | Date | Breaking Changes | Impact on EBS Migration |
|---|---|---|---|
| 25A | 2025-02 | New REST endpoints for several Financials objects | Update integration endpoints |
| 24D | 2024-11 | FBDI template format changes for Procurement | Re-download FBDI templates |
| 24C | 2024-08 | OAuth 2.0 enforcement for REST APIs | Migrate from basic auth |
| 24B | 2024-05 | New validation rules for supplier import | Update data cleansing rules |
| 24A | 2024-02 | BIP report format changes | Update custom report templates |

### Deprecation Policy

Oracle Fusion Cloud receives quarterly updates (24A, 24B, 24C, 24D per year) that are mandatory — customers cannot skip updates. Breaking changes are announced one quarter in advance via Cloud Readiness documentation. FBDI templates are updated in-place and backward compatibility is not guaranteed across releases. [src1]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Migrating from EBS 12.2 to Fusion Cloud ERP | Already on Fusion Cloud needing coexistence only | oracle-erp-cloud-coexistence-patterns/2026 |
| Planning integration redesign for EBS → Fusion | Need Fusion-to-Fusion API reference | Oracle Fusion Cloud REST API reference |
| Evaluating migration approaches (big-bang vs phased) | Need third-party ERP migration (SAP → Fusion) | Vendor-specific migration guides |
| Designing coexistence architecture during transition | Need Oracle Retail Suite upgrade specifically | oracle-retail-suite-upgrade-planning/2026 |

## Important Caveats

- EBS 12.2 Premier Support has been extended through at least 2035 — there is no forced migration deadline, but new features are cloud-only [src6]
- Migration timelines vary enormously: lightly customized EBS environments may take 12-18 months; heavily customized environments with 500+ custom objects commonly take 24-36 months
- Oracle offers migration accelerators and third-party tools (Datafusing, IT Convergence, etc.) that can reduce effort by 30-40% — but they do not eliminate the need for integration redesign [src5]
- Fusion Cloud is a multi-tenant SaaS environment — performance characteristics differ from dedicated on-premise EBS databases, especially for large batch operations
- FBDI templates and REST API endpoints change every quarter — always test integrations after each Fusion Cloud quarterly update

## Related Units

- [Oracle ERP Cloud Coexistence Patterns](/business/erp-integration/oracle-erp-cloud-coexistence-patterns/2026) — Running EBS and Fusion simultaneously during migration
- [Oracle Redwood UI Impact on Integrations](/business/erp-integration/oracle-redwood-ui-impact-integrations/2026) — How the Redwood UI migration affects custom pages and extensions
- [Oracle Retail Suite Upgrade Planning](/business/erp-integration/oracle-retail-suite-upgrade-planning/2026) — Upgrading Oracle Retail from 13.x to 23.x