---
# === IDENTITY ===
id: business/erp-integration/oracle-erp-cloud-customization-boundaries/2026
canonical_question: "What can and cannot be customized in Oracle ERP Cloud - flexfields, VBCS, Clean Core constraints?"
aliases:
  - "Oracle Fusion Cloud customization limits"
  - "Oracle ERP Cloud extensibility boundaries flexfields VBCS"
  - "What customizations are allowed in Oracle Cloud ERP Clean Core"
  - "Oracle Fusion Cloud Clean Core customization restrictions"
entity_type: erp_integration
domain: business > erp-integration > oracle-erp-cloud-customization-boundaries
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Oracle Fusion Cloud ERP"
    vendor: "Oracle"
    version: "25A-25D"
    edition: "Enterprise"
    deployment: cloud
    api_surface: "REST, SOAP, FBDI, VBCS"

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

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "25A — new Clean Core opt-in features auto-enabled"
  next_review: 2026-09-05
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Descriptive flexfields limited to 40 text, 20 numeric, 10 date segments (70 total) per object"
  - "Extensible flexfields require sandbox publish cycle before production availability"
  - "VBCS extensions must not modify Oracle-delivered page structure — side-car pattern only"
  - "Sandbox limit: 20 open sandboxes by default (profile option ORACLE.ADF.SHARE.SANDBOX.MAXIMUMSANDBOXCOUNT)"
  - "Personalization layer changes (Page Composer) can be overwritten by quarterly updates"
  - "No direct database access — all customization must go through supported APIs or configuration tools"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs to customize Oracle NetSuite, not Fusion Cloud ERP"
    use_instead: "business/erp-integration/netsuite-suitescript-governance/2026"
  - condition: "User needs to build a standalone app on Oracle Cloud Infrastructure"
    use_instead: "Search knowledgelib.io for building standalone apps on OCI - no dedicated unit yet"
  - condition: "User only needs to configure workflows without code"
    use_instead: "Search knowledgelib.io for Oracle ERP Cloud no-code workflow setup - no dedicated unit yet"

# === AGENT HINTS ===
inputs_needed:
  - key: customization_type
    question: "What type of customization do you need?"
    type: choice
    options:
      - "Add custom fields to existing objects (flexfields)"
      - "Build custom UI pages (VBCS)"
      - "Extend business logic (Application Composer)"
      - "Custom reports (OTBI, BI Publisher)"
      - "Integration extensions (REST API, web services)"
  - key: upgrade_sensitivity
    question: "How important is seamless quarterly upgrades?"
    type: choice
    options:
      - "Critical — must not break on any update"
      - "Important — willing to retest each quarter"
      - "Flexible — can accept some manual rework"
  - key: edition
    question: "Which Oracle Cloud ERP edition?"
    type: choice
    options:
      - "Enterprise"
      - "Standard"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/oracle-erp-cloud-customization-boundaries/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-upgrade-impact-integrations/2026"
      label: "How quarterly updates impact integrations"
    - id: "business/erp-integration/oracle-erp-cloud-sandbox-limitations/2026"
      label: "Sandbox limitations for testing customizations"
  solves: []
  alternative_to: []
  often_confused_with:
    - id: "business/erp-integration/oracle-erp-cloud-sandbox-limitations/2026"
      label: "Sandbox limitations (testing scope, not customization scope)"

# === SOURCES ===
sources:
  - id: src1
    title: "Oracle Cloud Extensibility Framework: Protect Upgrades, Customize Freely"
    author: Oracle
    url: https://www.oracle.com/a/ocom/docs/industries/industrial-manufacturing/cloud-extensibility-frameworks-upgrades.pdf
    type: official_docs
    published: 2024-01-15
    reliability: authoritative
  - id: src2
    title: "Best Practices for Configuring and Extending Fusion Applications Cloud"
    author: Oracle A-Team
    url: https://www.ateam-oracle.com/post/best-practices-for-configuring-and-extending-fusion-applications-cloud
    type: technical_blog
    published: 2024-06-10
    reliability: high
  - id: src3
    title: "How Flexfields Work with Oracle Application Cloud Architecture"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/saas/applications-common/25c/oaext/how-flexfields-work-with-oracle-application-cloud-architecture.html
    type: official_docs
    published: 2025-08-01
    reliability: authoritative
  - id: src4
    title: "Considerations for Managing Descriptive Flexfields"
    author: Oracle
    url: https://docs.oracle.com/en/cloud/saas/applications-common/25a/facia/considerations-for-managing-descriptive-flexfields.html
    type: official_docs
    published: 2025-02-01
    reliability: authoritative
  - id: src5
    title: "Customization Options for Oracle Fusion SaaS Applications"
    author: Apps Associates
    url: https://appsassociates.com/blog/customization-options-for-oracle-cloud-infrastructure/
    type: technical_blog
    published: 2024-09-15
    reliability: moderate_high
  - id: src6
    title: "Introduction to Customizing and Extending Oracle Fusion Applications"
    author: Oracle
    url: https://docs.oracle.com/applications/falcm12/OADTC/GUID-BCD03C5E-7F2B-4BEC-BB61-515CE8F27BB5.htm
    type: official_docs
    published: 2024-03-01
    reliability: authoritative
---

# Oracle ERP Cloud Customization Boundaries — Flexfields, VBCS, and Clean Core Constraints

## TL;DR

- **Bottom line**: Oracle Fusion Cloud ERP supports customization through a layered extensibility model — flexfields for data, Application Composer for logic, VBCS for UI, and Page Composer for layout — but all must follow Clean Core principles to survive quarterly updates.
- **Key limit**: Descriptive flexfields allow max 40 text + 20 numeric + 10 date segments (70 total) per object; extensible flexfields overcome this via multi-row/multi-context design. [src3]
- **Watch out for**: Page Composer personalizations and sandbox-based configurations can be overwritten or behave differently after quarterly updates if they touch Oracle-delivered components. [src2]
- **Best for**: Teams that need to extend Oracle ERP Cloud without forking the codebase or risking upgrade failures.
- **Authentication**: Not applicable — customization is configured through Oracle Fusion UI tools (Setup and Maintenance, Sandboxes, Application Composer).

## System Profile

Oracle Fusion Cloud ERP (releases 25A through 25D) provides a multi-layer extensibility framework designed to let customers add fields, business logic, UI pages, and integrations without modifying Oracle's core application code. This "Clean Core" approach ensures that quarterly updates can be applied without breaking customer customizations — provided those customizations stay within supported boundaries. This card covers Enterprise edition; Standard edition has more restricted extensibility options, particularly around Application Composer and VBCS. [src1]

| Property | Value |
|---|---|
| **Vendor** | Oracle |
| **System** | Oracle Fusion Cloud ERP (25A-25D) |
| **API Surface** | REST, SOAP, FBDI, VBCS |
| **Current Release** | 25D (November 2025) |
| **Editions Covered** | Enterprise (primary), Standard (limited extensibility) |
| **Deployment** | Cloud |
| **API Docs URL** | [Oracle Fusion Cloud Extensibility](https://docs.oracle.com/en/cloud/saas/applications-common/25c/oaext/) |
| **Status** | GA |

## API Surfaces & Capabilities

Oracle Fusion Cloud ERP offers multiple extensibility surfaces, each with distinct scope and upgrade safety characteristics. [src1, src2]

| Extensibility Surface | Scope | Best For | Upgrade Safe? | Requires Sandbox? | Clean Core Compliant? |
|---|---|---|---|---|---|
| Descriptive Flexfields (DFF) | Add fields to existing objects | Custom attributes (40 text + 20 num + 10 date per object) | Yes | Yes | Yes |
| Extensible Flexfields (EFF) | Multi-row, multi-context custom fields | Complex attribute groups, category-specific fields | Yes | Yes | Yes |
| Key Flexfields (KFF) | Chart of Accounts, item categories | Accounting structures, GL segments | Yes | No (Setup task) | Yes |
| Application Composer | Business logic, objects, validation | Custom objects, triggers, object workflows | Yes | Yes | Yes |
| Page Composer | UI layout changes | Hide/show fields, reorder sections | Partial | Yes | Conditional |
| VBCS (Visual Builder) | Custom UI pages | Side-car apps, custom dashboards | Yes | No | Yes (side-car only) |
| BI Publisher / OTBI | Custom reports | Financial reports, operational analytics | Yes | No | Yes |
| REST API Extensions | Custom endpoints | Integration-facing custom services | Yes | No | Yes |
| Groovy Scripts | Server-side logic | Field validation, calculated fields, triggers | Yes | Yes | Yes |

## Rate Limits & Quotas

### Flexfield Segment Limits

| Limit Type | Value | Applies To | Notes |
|---|---|---|---|
| Text segments per DFF | 40 | Descriptive Flexfields | String type attributes |
| Numeric segments per DFF | 20 | Descriptive Flexfields | Number type attributes |
| Date segments per DFF | 10 | Descriptive Flexfields | Date/DateTime type attributes |
| Total segments per DFF | 70 | Descriptive Flexfields | Combined maximum across all types |
| Contexts per DFF | No hard limit | Descriptive Flexfields | Practical limit ~50 for UI performance |
| EFF categories | No hard limit | Extensible Flexfields | Multi-row overcomes DFF limits |
| EFF pages per context | 10 | Extensible Flexfields | UI rendering constraint |

[src3, src4]

### Sandbox Limits

| Limit Type | Value | Window | Notes |
|---|---|---|---|
| Open sandboxes | 20 | Per environment | Controlled by ORACLE.ADF.SHARE.SANDBOX.MAXIMUMSANDBOXCOUNT |
| Sandbox users | 1 recommended | Per sandbox | Multiple users possible but risk merge conflicts |
| Publish frequency | No limit | Per day | Each publish requires full regression consideration |

[src2]

### Application Composer Limits

| Limit Type | Value | Notes |
|---|---|---|
| Custom objects | 200 per pillar | Across all ERP modules |
| Custom fields per object | 100 | Includes both standard and custom fields exposed |
| Groovy script size | 64 KB | Per trigger/validation script |
| Object workflow rules | 50 per object | Including both active and inactive |
| Saved search limits | 25 per user per object | User-level constraint |

[src6]

## Authentication

| Flow | Use When | Notes |
|---|---|---|
| Setup and Maintenance UI | Configuration tasks (flexfields, lookups) | Requires IT Security Manager or Application Implementation Consultant role |
| Sandbox UI | Development/testing of customizations | Requires Customization Developer or higher role |
| Application Composer | Business logic extensions | Requires Application Implementation Consultant role |
| VBCS Studio | Custom UI page development | Requires VBCS access provisioned via Oracle Integration Cloud |
| REST API (OAuth 2.0) | Programmatic extensions | JWT bearer or authorization code flow |

### Authentication Gotchas

- Sandbox access requires explicit role assignment — the Customization Developer role is not granted by default even to admin users. [src2]
- VBCS development requires a separate Oracle Integration Cloud (OIC) subscription — it is not included in the base ERP license for standalone use. [src5]
- Page Composer changes made by one user in a sandbox are not visible to other users until the sandbox is published. [src2]

## Constraints

- Descriptive flexfields are limited to 70 total segments (40 text + 20 numeric + 10 date) per business object — use extensible flexfields for complex attribute requirements. [src3]
- VBCS custom pages must follow the side-car application pattern — directly modifying Oracle-delivered page structure is not supported and will break on updates. [src1]
- Page Composer personalizations that reference Oracle-delivered component IDs may stop working after quarterly updates if Oracle changes the component structure. [src2]
- Groovy scripts in Application Composer have a 64 KB size limit per trigger and cannot make external HTTP callouts directly — use scheduled processes or BIP reports for external integration. [src6]
- Custom objects created in Application Composer are pillar-specific (ERP, HCM, CX) and cannot span pillars without REST API integration between them. [src1]
- Sandbox configurations must be published to mainline before they are visible in production — unpublished sandboxes are completely isolated. [src2]

## Integration Pattern Decision Tree

```
START — User needs to customize Oracle Fusion Cloud ERP
├── What needs customization?
│   ├── Additional data fields on existing objects
│   │   ├── Simple attributes (< 70 segments)?
│   │   │   ├── YES → Descriptive Flexfields (DFF)
│   │   │   └── NO → Extensible Flexfields (EFF) for multi-row/multi-context
│   │   └── Accounting structure / GL segments?
│   │       └── YES → Key Flexfields (KFF)
│   ├── Business logic / validation rules
│   │   ├── Field-level validation?
│   │   │   └── YES → Groovy scripts in Application Composer
│   │   ├── Object-level workflows?
│   │   │   └── YES → Object Workflows in Application Composer
│   │   └── Cross-module orchestration?
│   │       └── YES → BPM Workflow or OIC (outside ERP)
│   ├── Custom UI pages
│   │   ├── New standalone page?
│   │   │   └── YES → VBCS side-car application
│   │   ├── Modify existing page layout?
│   │   │   └── YES → Page Composer (with upgrade risk awareness)
│   │   └── Custom dashboard / analytics?
│   │       └── YES → OTBI or BI Publisher
│   ├── Custom reports
│   │   ├── Operational / transactional?
│   │   │   └── YES → OTBI (Oracle Transactional BI)
│   │   └── Formatted / printable?
│   │       └── YES → BI Publisher
│   └── Integration with external systems
│       ├── Real-time data exchange?
│       │   └── YES → REST API + OIC
│       └── Bulk data load?
│           └── YES → FBDI or File Import
├── Must survive quarterly updates without rework?
│   ├── YES → Use only Clean Core compliant surfaces (flexfields, App Composer, VBCS side-car, REST API)
│   └── NO → Page Composer acceptable but plan for regression testing
└── Need to test before production?
    └── ALWAYS → Use sandbox environment, publish only after validation
```

## Quick Reference

| Customization Need | Recommended Tool | Clean Core? | Upgrade Risk | Effort |
|---|---|---|---|---|
| Add custom field to PO | Descriptive Flexfield | Yes | None | Low |
| Multi-row attributes on items | Extensible Flexfield | Yes | None | Medium |
| Validate field on save | Groovy script (App Composer) | Yes | None | Low |
| Custom approval workflow | Object Workflow (App Composer) | Yes | None | Medium |
| New standalone UI page | VBCS side-car app | Yes | None | High |
| Rearrange fields on existing page | Page Composer | Conditional | Medium | Low |
| Hide delivered fields | Page Composer | Conditional | Low | Low |
| Custom financial report | BI Publisher | Yes | None | Medium |
| Ad-hoc query / dashboard | OTBI | Yes | None | Low |
| Bulk data import customization | FBDI template modification | Yes | Low | Medium |
| Custom REST endpoint | REST API via OIC | Yes | None | High |
| Custom database table | Not supported | No | N/A | N/A |

## Step-by-Step Integration Guide

### 1. Create a Descriptive Flexfield Segment

Navigate to Setup and Maintenance, search for "Manage Descriptive Flexfields," select the target business object (e.g., PO Headers), create a new context and segments. [src4]

```
Setup and Maintenance → Search: "Manage Descriptive Flexfields"
→ Select business object (e.g., "PO_HEADERS")
→ Click "+" to add Context
→ Add Segments: Name, API Name, Data Type, Length
→ Deploy Flexfield
→ Verify in Sandbox before publishing
```

**Verify**: Navigate to the business object form (e.g., Purchase Order) → check that the new field appears under the "Additional Information" region.

### 2. Build a VBCS Side-Car Application

Create a Visual Builder application that runs alongside Oracle Fusion Cloud ERP, consuming REST APIs to read/write ERP data. [src1, src5]

```
Oracle Integration Cloud → Visual Builder Studio
→ Create New Application
→ Add Service Connection → Oracle Fusion REST API
→ Design pages using drag-and-drop
→ Deploy as side-car (embedded in Fusion Navigator or standalone URL)
```

**Verify**: Access the VBCS app URL → confirm it loads within the Fusion Cloud navigation structure and can read/write ERP data via REST.

### 3. Add Groovy Validation in Application Composer

Use Application Composer to add server-side validation logic to standard or custom objects. [src6]

```groovy
// Example: Validate that PO amount does not exceed budget
def poAmount = TotalAmount
def budgetLimit = 50000

if (poAmount > budgetLimit) {
    throw new oracle.jbo.ValidationException(
        "PO amount ${poAmount} exceeds budget limit of ${budgetLimit}"
    )
}
```

**Verify**: Create a test PO with amount > 50,000 → confirm validation error appears on save.

### 4. Publish Sandbox to Mainline

After testing all customizations in the sandbox, publish to make them available in the production environment. [src2]

```
Navigator → Sandboxes → Select sandbox
→ Review changes summary
→ Click "Publish"
→ Confirm publication
→ Wait for publish process to complete (may take 5-30 minutes)
```

**Verify**: Log in as a different user without sandbox access → confirm customizations are visible and functional.

## Code Examples

### Python: Query Custom Flexfield Values via REST API

```python
# Input:  Oracle Fusion Cloud REST API credentials, PO Header ID
# Output: PO Header with custom flexfield (DFF) values

import requests

base_url = "https://your-instance.fa.us2.oraclecloud.com"
endpoint = f"{base_url}/fscmRestApi/resources/11.13.18.05/purchaseOrders"

headers = {
    "Authorization": "Bearer YOUR_ACCESS_TOKEN",
    "Content-Type": "application/json"
}

# Query PO with DFF expansion
params = {
    "q": "OrderNumber=PO-10001",
    "expand": "DFF",
    "fields": "POHeaderId,OrderNumber,DFF"
}

response = requests.get(endpoint, headers=headers, params=params)
if response.status_code == 200:
    po_data = response.json()
    for item in po_data.get("items", []):
        print(f"PO: {item['OrderNumber']}")
        dff = item.get("DFF", [{}])
        if dff:
            print(f"  Custom Fields: {dff}")
else:
    print(f"Error: {response.status_code} - {response.text}")
```

### cURL: Check Available Flexfields on a Business Object

```bash
# Input:  Valid OAuth token, Oracle Fusion Cloud instance URL
# Output: List of flexfield segments configured on PO Headers

curl -X GET \
  "https://your-instance.fa.us2.oraclecloud.com/fscmRestApi/resources/11.13.18.05/purchaseOrders/describe" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" | python -m json.tool

# Look for "DFF" child resource in the describe output
# Each segment will show: name, type, required, maxLength
```

## Data Mapping

### Flexfield Configuration Reference

| Configuration | Tool | Location | API Access |
|---|---|---|---|
| Descriptive Flexfield | Setup and Maintenance | Manage Descriptive Flexfields | REST: expand=DFF on parent object |
| Extensible Flexfield | Setup and Maintenance | Manage Extensible Flexfields | REST: expand=EFF on parent object |
| Key Flexfield | Setup and Maintenance | Manage Chart of Accounts | REST: accountCombination resource |
| Custom Object | Application Composer | Custom Objects | REST: auto-generated endpoint |
| Page Layout | Page Composer | In-page editing | Not API-accessible |
| VBCS App | Visual Builder Studio | OIC Console | Custom endpoints |

### Data Type Gotchas

- Flexfield segments exposed via REST API use the segment's API name (not display name) — API names cannot be changed after deployment without re-creating the segment. [src3]
- Date-type DFF segments return UTC timestamps via REST API but display in the user's timezone in the UI — conversion logic is required for integrations. [src4]
- Numeric DFF segments use Oracle's NUMBER type internally — precision beyond 38 digits is not supported, and rounding behavior differs from JavaScript's floating point. [src3]

## Error Handling & Failure Points

### Common Error Codes

| Code | Meaning | Cause | Resolution |
|---|---|---|---|
| JBO-27024 | Attribute not found | Flexfield segment not deployed or wrong API name | Deploy flexfield and verify API name in describe endpoint |
| JBO-27014 | Attribute set failed | Validation rule on flexfield segment failed | Check value set constraints and Groovy validators |
| SANDBOX-001 | Sandbox publish failed | Conflicting changes between sandbox and mainline | Merge conflicts manually, recreate sandbox if needed |
| ADF-00001 | Page rendering error | Page Composer customization references removed component | Remove broken customization from sandbox |
| ORA-20001 | Custom validation error | Groovy script threw ValidationException | Review Groovy script logic and error message |

### Failure Points in Production

- **Flexfield deployment fails silently**: Deploying a flexfield does not always provide clear error messages. If the flexfield does not appear after deployment, check the ESS job log for the deployment process. Fix: Navigate to Scheduled Processes → search for the flexfield deployment job → review output log. [src4]
- **Sandbox publish causes data loss**: If two sandboxes modify the same object, the second publish can overwrite the first. Fix: Always use a single sandbox per object being customized, and review change summary before publishing. [src2]
- **Page Composer changes break after quarterly update**: Oracle may restructure delivered pages, causing Page Composer customizations that reference specific component IDs to fail. Fix: Test all Page Composer customizations in the test pod after each quarterly update before production. [src2]
- **VBCS app loses connectivity after update**: If Oracle changes REST API versions or endpoints between releases, VBCS service connections may break. Fix: Pin VBCS service connections to specific API versions and test after each quarterly update. [src1]

## Anti-Patterns

### Wrong: Customizing Oracle-Delivered Pages Directly via Page Composer for Complex Changes

```
// ❌ BAD — Deep Page Composer changes that reference internal component IDs
// Moving delivered components, changing bindings, adding complex logic
// via Page Composer rather than VBCS
// Risk: Quarterly update changes component IDs → customization breaks silently
```

### Correct: Build Side-Car VBCS Application for Complex UI Requirements

```
// ✅ GOOD — VBCS side-car app consumes REST APIs
// Decoupled from delivered page structure
// Survives quarterly updates because it only depends on REST API contract
// Deploy → Navigator → custom menu entry
```

### Wrong: Exceeding DFF Segment Limits by Creating Multiple DFFs on Same Object

```
// ❌ BAD — Trying to bypass 70-segment limit by creating
// additional DFF contexts with overlapping purposes
// Results in: confusing UI, performance degradation, maintenance nightmare
```

### Correct: Use Extensible Flexfields for Complex Attribute Requirements

```
// ✅ GOOD — EFF supports multi-row, multi-context design
// Each EFF category can have its own set of segments
// No hard limit on total segments across categories
// Better UI organization with tabbed display
```

### Wrong: Writing Groovy Scripts That Make External HTTP Calls

```groovy
// ❌ BAD — Groovy scripts cannot make external HTTP callouts
// This will fail silently or throw a security exception
def url = new URL("https://external-api.example.com/validate")
def connection = url.openConnection()
// Will not work — sandboxed execution environment
```

### Correct: Use Scheduled Processes or OIC for External Integrations

```groovy
// ✅ GOOD — Set a flag field that OIC monitors
// OIC picks up the change via Business Events or polling
// and makes the external API call
setAttribute("ExternalValidationRequired", "Y")
setAttribute("ExternalValidationStatus", "PENDING")
// OIC integration polls for PENDING records and processes them
```

## Common Pitfalls

- **Not deploying flexfields after configuration**: Flexfields must be explicitly deployed (Setup → Manage Flexfields → Deploy) before they appear in the UI or REST API. Saving the configuration alone is not enough. Fix: Always click "Deploy Flexfield" after making changes, then verify via the REST describe endpoint. [src3]
- **Ignoring sandbox isolation**: Changes made in a sandbox are completely invisible to all other users and processes until published. This means integrations and batch processes will not see sandbox-configured flexfields. Fix: Test integrations only after publishing the sandbox to mainline. [src2]
- **Using Page Composer for what should be VBCS**: Page Composer is convenient for simple layout changes but becomes a maintenance burden for complex customizations. Fix: If the customization requires more than hiding/showing fields or reordering, use VBCS. [src1]
- **Not backing up sandbox before publishing**: There is no undo for sandbox publish. If the published changes cause issues, the only remedy is to manually revert each change. Fix: Document all sandbox changes before publishing and maintain a test script to validate post-publish. [src2]
- **Assuming Standard edition has same extensibility as Enterprise**: Standard edition has significant restrictions on Application Composer, VBCS access, and custom object creation. Fix: Verify extensibility features available in your edition before planning customizations. [src5]

## Diagnostic Commands

```bash
# Check deployed flexfield status via REST API describe
curl -X GET \
  "https://your-instance.fa.us2.oraclecloud.com/fscmRestApi/resources/11.13.18.05/purchaseOrders/describe" \
  -H "Authorization: Bearer $TOKEN" | \
  python -c "import sys,json; d=json.load(sys.stdin); print(json.dumps([c for c in d.get('children',[]) if 'FF' in c.get('name','')], indent=2))"

# List open sandboxes
# Navigate to: Navigator → Sandboxes → view all open sandboxes
# Or query via REST:
curl -X GET \
  "https://your-instance.fa.us2.oraclecloud.com/hcmRestApi/resources/11.13.18.05/sandboxes" \
  -H "Authorization: Bearer $TOKEN"

# Check Application Composer custom objects
# Navigate to: Navigator → Application Composer → Custom Objects
# Review object count against 200-per-pillar limit

# Verify VBCS application deployment status
# Navigate to: OIC Console → Visual Builder → Applications
# Check application status: Stage / Live / Error
```

## Version History & Compatibility

| Release | Date | Status | Key Changes | Impact on Customizations |
|---|---|---|---|---|
| 25D | 2025-11 | Current | New Redwood UI components, enhanced VBCS | Minor — test Page Composer customizations |
| 25C | 2025-08 | Supported | Extended EFF API support | Positive — more EFF segments accessible via REST |
| 25B | 2025-05 | Supported | Application Composer enhancements | Minor — new Groovy functions available |
| 25A | 2025-02 | Supported | Clean Core opt-in features auto-enabled | Medium — review auto-enabled features |
| 24D | 2024-11 | Supported | VBCS embedded app framework GA | Positive — new side-car deployment model |

[src1, src2]

### Deprecation Policy

Oracle Fusion Cloud ERP follows a quarterly release cadence (A/B/C/D per year). Features are never removed without at least two quarterly releases of deprecation notice. However, UI component structure changes (which break Page Composer customizations) are not considered breaking changes by Oracle. [src1]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| Adding custom fields to standard objects (< 70 per object) | Need > 70 custom attributes on a single object | Extensible Flexfields (EFF) |
| Simple UI layout changes (hide/show/reorder) | Complex custom UI with external data sources | VBCS side-car application |
| Field-level validation or calculation | Cross-module business orchestration | OIC (Oracle Integration Cloud) |
| Custom reports on ERP data | Real-time streaming analytics | Oracle Analytics Cloud |
| Bulk data import with custom mappings | Real-time API integration | REST API + OIC |

## Important Caveats

- Page Composer customizations are the most common source of post-upgrade issues — Oracle does not guarantee component ID stability between quarterly updates. [src2]
- VBCS development requires Oracle Integration Cloud (OIC) subscription — this is a separate license cost beyond the base ERP subscription. [src5]
- Flexfield segment API names cannot be changed after initial deployment without recreating the segment — plan API names carefully before deploying. [src3]
- The 20-sandbox limit can be increased but may degrade environment performance — Oracle recommends keeping active sandboxes under 10 for optimal performance. [src2]
- Clean Core compliance is a spectrum, not binary — even "compliant" customizations should be regression tested after each quarterly update as Oracle may change behavior of delivered components they depend on.

## Related Units

- [Oracle ERP Cloud Quarterly Update Impact on Integrations](/business/erp-integration/oracle-erp-cloud-upgrade-impact-integrations/2026)
- [Oracle ERP Cloud Sandbox Limitations](/business/erp-integration/oracle-erp-cloud-sandbox-limitations/2026)