Oracle VBCS vs Custom Pages vs Embedded Analytics for ERP UI Extensions

TL;DR

• Bottom line: Use Visual Builder Studio (VBS, embedded in Fusion) for modifying Redwood pages and creating new internal-facing App UIs; use standalone VBCS only when you need external user access, custom database storage, or secured third-party REST APIs.
• Key limit: VBS (embedded) cannot connect to external databases or create custom business objects — it can only access Fusion Business Objects via the Service Catalog and call unsecured external REST endpoints.
• Watch out for: Confusing VBS (embedded, free with Fusion license) with standalone VBCS (requires separate OIC license) — they share the same UI builder but have different deployment models, data access, and licensing.
• Best for: Organizations extending Oracle Fusion Cloud ERP/HCM/CX with custom Redwood pages, conditional field visibility, new App UIs, and embedded workflows — all without leaving the Fusion security context.
• Authentication: VBS extensions inherit Fusion's identity and SSO automatically; standalone VBCS requires OAuth 2.0 or SAML configuration for Fusion REST API access.

System Profile

Oracle provides two deployment modes for Visual Builder that share the same low-code development environment but differ significantly in capability, licensing, and integration scope. Visual Builder Studio (VBS) is embedded within Oracle Fusion Cloud Applications and included in the SaaS license. Standalone Visual Builder Cloud Service (VBCS), part of Oracle Integration Cloud (OIC), runs on a separate OCI tenancy and can connect to external databases, custom business objects, and secured third-party REST services. This card covers both modes and when to choose each, alongside Page Composer, Application Composer, and embedded analytics (OTBI/BIP) as alternative extension approaches. [src1, src3, src4]

API Surfaces & Capabilities

This section maps the UI extension tools available for Oracle Fusion Cloud, not traditional API surfaces. Each tool addresses a different extension need. [src1, src3, src4]

Rate Limits & Quotas

Per-Instance Limits

[src5]

Rolling / Daily Limits

[src5, src6]

Authentication

[src4, src7]

Authentication Gotchas

• VBS (embedded) identity propagation means all REST calls run as the logged-in Fusion user — field-level security and data security policies apply to API responses, which can cause different users to see different data in the same custom page. [src1]
• Standalone VBCS connecting back to Fusion REST requires a Connected App registration in Fusion IAM (IDCS or OCI IAM) — this is a multi-step setup involving redirect URIs, scope definitions, and token endpoints. [src7]
• When VBS extensions call external REST endpoints, the call originates from Oracle's cloud infrastructure IP ranges — firewalls on the target service must allowlist Oracle Cloud IP ranges, not individual user IPs. [src7]

Constraints

• VBS (embedded) is limited to Fusion Business Objects via the Service Catalog — it cannot create or access custom database tables. If the requirement includes custom data persistence, use standalone VBCS with ATP/DBCS. [src3]
• VBS (embedded) can only call unsecured external REST endpoints natively — secured external REST requires Oracle Fusion IAM domain configuration (not trivial). [src3, src7]
• Page Composer modifications are metadata-only — they cannot add application logic, custom validations, or complex conditional workflows. [src3]
• Application Composer custom objects support simple forms and Groovy scripts but not complex multi-step UIs or Redwood layouts. [src3]
• All VBS extensions must follow Redwood design guidelines — custom CSS or non-Redwood components risk breaking during quarterly Fusion updates. [src2]
• Extensions should be modular and not hardcode dependencies on specific Fusion application versions — Oracle delivers quarterly updates that can change internal page structures. [src2]
• OTBI reports can be embedded in Fusion pages but cannot be authored or modified via VBCS — they require separate OTBI/BIP authoring tools. [src3]
• Standalone VBCS apps deployed outside Fusion do not inherit Fusion's navigation, Springboard, or role-based menu — they run as separate web applications. [src4]

Integration Pattern Decision Tree

START — User needs to extend Oracle Fusion Cloud ERP UI
|
+-- What type of extension?
|   |
|   +-- Modify existing Redwood page (add/remove/reorder fields)?
|   |   |
|   |   +-- Simple field show/hide/reorder only?
|   |   |   +-- YES -> Page Composer (no code, instant)
|   |   |   +-- NO (need conditional logic, action chains) -> VBS Page Extension
|   |   |
|   |   +-- Need to add new custom fields to data model?
|   |       +-- YES -> Application Composer (custom fields + Groovy)
|   |       +-- Then use VBS to control UI rendering
|   |
|   +-- Create entirely new application page?
|   |   |
|   |   +-- Internal Fusion users only?
|   |   |   +-- Data from Fusion BOs only?
|   |   |   |   +-- YES -> VBS App UI (embedded, free)
|   |   |   |   +-- NO -> Need custom DB?
|   |   |   |       +-- YES -> Standalone VBCS + ATP
|   |   |   |       +-- NO (external unsecured REST) -> VBS App UI
|   |   |   +-- Need secured external REST?
|   |   |       +-- Configure Fusion IAM for VBS, or use Standalone VBCS
|   |   |
|   |   +-- External users (partners, suppliers, customers)?
|   |       +-- YES -> Standalone VBCS (separate URL, own auth)
|   |       +-- Consider Oracle APEX for complex external portals
|   |
|   +-- Embed analytics/reports in Fusion pages?
|   |   |
|   |   +-- Operational reporting (real-time Fusion data)?
|   |   |   +-- OTBI (embedded, included in license)
|   |   |
|   |   +-- Pixel-perfect output (PDF, Excel)?
|   |   |   +-- BIP (BI Publisher)
|   |   |
|   |   +-- Advanced analytics (ML, cross-source)?
|   |       +-- Oracle Analytics Cloud (separate license)
|   |
|   +-- Need complex custom logic + database + full-stack?
|       +-- Oracle APEX (PL/SQL, full DB access)
|       +-- ADF is deprecated for new development
|
+-- Licensing check
    +-- Embedded VBS -> Included in Fusion Apps license
    +-- Standalone VBCS -> Requires Oracle Integration Cloud license
    +-- APEX -> Requires OCI/ATP license
    +-- OAC -> Requires separate Oracle Analytics Cloud license

Quick Reference

Step-by-Step Integration Guide

1. Determine extension type and tool selection

Audit the business requirement against the decision tree above. Key questions: Does the extension need custom database storage? Does it serve external users? Does it need secured external REST calls? If all answers are "no," VBS (embedded) is the correct choice and requires no additional licensing. [src3, src4]

Verify: Check your Oracle Fusion Cloud subscription includes Visual Builder Studio access -> navigate to Developer Tools in Fusion navigator.

2. Create a VBS workspace and project

In Oracle Fusion, navigate to Configuration -> Visual Builder Studio. Create a new workspace, select the target Fusion environment, and create an extension project. VBS automatically provisions a Git repository for version control. [src2]

Fusion Navigator -> Tools -> Visual Builder Studio
-> Create Workspace -> Select Environment
-> Create Extension Project -> Select target module (ERP, HCM, CX)

Verify: Workspace dashboard shows connected environment with green status indicator.

3. Create an App UI or Page Extension

For a new page: create an App UI within the extension. For modifying an existing page: create a Page Extension targeting the specific delivered page. Use Dynamic Forms and Dynamic Containers for conditional content. [src1]

Extension Project -> + New -> App UI (for new page)
                           -> Page Extension (to modify existing)
-> Drag components (Forms, Tables, Containers)
-> Bind to Fusion Business Objects via Service Catalog
-> Configure rule sets for conditional display

Verify: Preview the extension in the VBS design-time preview -> confirm data binding shows live Fusion data.

4. Configure REST service connections

For Fusion Business Objects: use the built-in Service Catalog (no configuration needed). For external REST APIs (unsecured): add a Service Connection with the endpoint URL. For external REST APIs (secured): configure the connection through Fusion IAM domain with appropriate OAuth scopes. [src7]

App UI -> Services tab -> + Service Connection
-> From Service Catalog (Fusion BOs) — auto-discovered
-> From Endpoint URL (external REST) — paste URL, test
-> Authentication: None (unsecured) or configure in IAM

Verify: Test the service connection from the VBS Services tab -> should return HTTP 200 with sample data.

5. Implement action chains and business logic

Use action chains for event-driven logic: button clicks, page load, value changes. Action chains support REST calls, navigation, variable assignment, conditional branching, and JavaScript functions. [src1, src2]

Verify: Run the action chain in design-time debugger -> step through each action and confirm variable assignments.

6. Deploy the extension to sandbox and production

VBS uses a sandbox model: deploy to a sandbox first for testing, then publish to production. The CI/CD pipeline in VBS supports automated packaging and deployment. [src2]

VBS -> Build -> Package Extension
    -> Deploy to Sandbox (test with sandbox users)
    -> Verify in Fusion UI (sandbox mode)
    -> Publish to Production
    -> Monitor via VBS deployment history

Verify: Access the target Fusion page in sandbox mode -> confirm extension is active and functional.

Code Examples

JavaScript: Action Chain — Call Fusion REST API and Process Response

// Input:  Fusion Business Object name, filter criteria
// Output: Filtered records displayed in a table component

// In a VBS Action Chain JavaScript function step:
define([], function () {
  'use strict';
  var PageModule = function PageModule() {};

  PageModule.prototype.filterPurchaseOrders = function (status, dateFrom) {
    var filter = 'Status eq "' + status + '"';
    if (dateFrom) {
      filter += ' and CreationDate ge "' + dateFrom + '"';
    }
    return filter;
  };

  return PageModule;
});

cURL: Test Fusion REST API from Standalone VBCS

# Input:  OAuth access token, Fusion instance URL
# Output: List of purchase orders in JSON format

# 1. Obtain OAuth token (standalone VBCS to Fusion)
curl -X POST "https://{fusion-instance}/oauth2/v1/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=authorization_code&code={auth_code}&client_id={client_id}&client_secret={secret}&redirect_uri={redirect}"

# 2. Query Purchase Orders via Fusion REST API
curl -X GET "https://{fusion-instance}/fscmRestApi/resources/11.13.18.05/purchaseOrders?limit=25&onlyData=true" \
  -H "Authorization: Bearer {access_token}" \
  -H "Content-Type: application/json"

# Expected: JSON array of PO records with OrderNumber, Status, Supplier

Data Mapping

Extension Tool Capability Matrix

Data Type Gotchas

• Fusion REST API date fields use ISO 8601 format but the VBS date picker component may default to the user's locale format — always use explicit date formatting in action chains. [src1]
• Fusion Business Object LOVs (List of Values) require a separate REST call to fetch valid values — do not hardcode LOV options in VBS pages as they may change with Fusion updates. [src1]
• Custom fields added via Application Composer appear in the Fusion REST API with a "__c" suffix — use the Service Catalog in VBS to discover the correct field names. [src3]

Error Handling & Failure Points

Common Error Scenarios

[src1, src7]

Failure Points in Production

• Quarterly update breaks extension: Oracle quarterly updates can change internal page structures. Extensions that hardcode selectors or depend on specific DOM elements break silently. Fix: Follow Redwood extension guidelines; use only supported extension points; test in sandbox before update goes live. [src2]
• Identity propagation failure after IAM migration: When Fusion migrates from IDCS to OCI IAM, VBS service connections may lose identity propagation. Fix: Reconfigure service connections in VBS after IAM migration; update redirect URIs and token endpoints. [src7]
• VBS Git merge conflicts on multi-developer projects: Multiple developers modifying the same extension create JSON merge conflicts in the page model. Fix: Use feature branches; merge frequently; resolve conflicts in VBS merge tool. [src2]
• Standalone VBCS OIC message quota exhaustion: Each REST call from standalone VBCS consumes OIC message credits. High-traffic apps can exhaust the monthly quota. Fix: Monitor OIC message consumption; implement client-side caching; upgrade OIC license tier. [src3]
• Embedded OTBI report parameters not passing correctly: URL-encoded parameters can be double-encoded when embedding OTBI via iframe. Fix: Use single encodeURIComponent call; test parameter passthrough in browser dev tools. [src3]

Anti-Patterns

Wrong: Building a standalone VBCS app when embedded VBS suffices

// BAD — Creates licensing cost, deployment complexity, and SSO configuration overhead
// when the requirement is simply a new internal Fusion page
Requirement: "Add a custom PO approval dashboard for internal procurement team"
Approach: Deploy standalone VBCS on OIC, configure OAuth, build separate app
Result: $5K-15K/year additional OIC licensing, weeks of IAM configuration

Correct: Use VBS App UI for internal-only pages

// GOOD — No additional licensing, inherits Fusion SSO, follows Redwood UX
Requirement: "Add a custom PO approval dashboard for internal procurement team"
Approach: Create VBS App UI, bind to PO Business Objects via Service Catalog
Result: Included in existing license, deployed in hours, consistent UX

Wrong: Using Page Composer for complex conditional logic

// BAD — Page Composer can only show/hide fields based on simple conditions
// It cannot implement multi-step workflows or call external services
Requirement: "Show different form sections based on PO amount and supplier risk score"
Approach: Use Page Composer to create conditional visibility rules
Result: Partial solution at best; no way to call risk API or chain conditions

Correct: Use VBS Dynamic Forms with Rule Sets

// GOOD — Full conditional logic with action chains and rule sets
Requirement: "Show different form sections based on PO amount and supplier risk score"
Approach: VBS Dynamic Form with rule sets; action chain calls risk API; conditional containers
Result: Full business logic support, maintainable, version-controlled

Wrong: Hardcoding Fusion REST API URLs in extensions

// BAD — URL changes with Fusion updates and environment differences
var poUrl = "https://fa-prod.oraclecloud.com/fscmRestApi/resources/11.13.18.05/purchaseOrders";

Correct: Use Service Catalog bindings in VBS

// GOOD — Service Catalog abstracts the URL and handles versioning
// In VBS, bind to Service Catalog BO "purchaseOrders"
// VBS resolves the correct endpoint at runtime
// No hardcoded URLs, works across dev/test/prod environments

Common Pitfalls

• Confusing VBS and standalone VBCS licensing: VBS (embedded in Fusion) is free with your Fusion license. Standalone VBCS requires an Oracle Integration Cloud license. Choosing standalone when embedded would suffice wastes budget. Fix: Use the decision tree above; choose standalone only when external users, custom DB, or secured external REST is required. [src3, src4]
• Not testing extensions in sandbox before quarterly updates: Oracle's quarterly Fusion updates can break extensions that use unsupported extension points. Fix: Deploy to sandbox before production; subscribe to Oracle release readiness notifications; test 4-6 weeks before update. [src2]
• Ignoring Redwood design guidelines: Custom CSS, non-standard components, or third-party UI libraries in VBS extensions create upgrade risk and inconsistent UX. Fix: Use only Redwood-approved components from the VBS palette; follow Oracle's Redwood Design System documentation. [src2, src4]
• Over-engineering with Application Composer: Application Composer handles simple custom fields and basic Groovy scripts, but complex UI attempts become unmaintainable. Fix: Use App Composer for data model extensions; use VBS for UI logic and complex workflows. [src3]
• Not planning for IAM changes: Oracle is migrating Fusion customers from IDCS to OCI IAM. Extensions with hardcoded IDCS endpoints break during migration. Fix: Use relative URLs for auth endpoints; monitor Oracle's IAM migration timeline. [src7]
• Embedding OTBI reports without considering performance: Iframe-embedded OTBI reports load asynchronously and can slow down the host VBS page. Fix: Limit to 1-2 embedded reports per page; use lazy loading; consider OAC for dashboard-heavy pages. [src3]

Diagnostic Commands

# Check VBS workspace status and connected environments
# Navigate to: Fusion -> Tools -> Visual Builder Studio -> Environments tab
# Verify: Environment shows "Connected" with green indicator

# Test Fusion REST API availability (from standalone VBCS or external)
curl -s -o /dev/null -w "%{http_code}" \
  "https://{fusion-instance}/fscmRestApi/resources/11.13.18.05/purchaseOrders?limit=1" \
  -H "Authorization: Bearer {token}"
# Expected: 200

# Verify Service Catalog BO availability in VBS
# In VBS App UI: Services tab -> Service Catalog -> Search for BO name
# Verify: BO appears with available operations (GET, POST, PATCH, DELETE)

# Check OIC message consumption (standalone VBCS)
# Navigate to: OCI Console -> Integration -> Monitoring -> Message Usage
# Verify: Usage is within licensed message pack limit

Version History & Compatibility

[src6]

When to Use / When Not to Use

Cross-System Comparison

Important Caveats

• VBS extension capabilities vary by Fusion module — ERP, HCM, and CX have different extension point coverage. Not all delivered pages support Page Extensions or Dynamic Containers yet. Always check Oracle's extension availability matrix for your specific module and release. [src1]
• The distinction between VBS (embedded, free) and standalone VBCS (requires OIC license) is critical for budgeting. Many implementation partners conflate the two, leading to unexpected licensing costs. [src3, src4]
• Oracle's quarterly update cadence means extensions need ongoing maintenance. Budget for 2-4 hours of testing per extension per quarterly update. [src2]
• OTBI and BIP reports embedded in Fusion pages cannot be modified or authored via VBS — they require separate OTBI/BIP authoring tools and have their own development lifecycle. [src3]
• Oracle is actively expanding Redwood page coverage across Fusion modules. Pages still on the Classic (ADF) UI cannot be extended via VBS — they require Page Composer or Application Composer. Check Oracle's Redwood readiness documentation for your module. [src4, src6]