Fusion Extensibility Handbook

Introduction

Oracle Fusion Applications Development and Extensibility Handbook is a critical topic for anyone working in modern cloud ERP, especially within Oracle Corporation’s SaaS ecosystem. In real-world implementations, clients rarely accept a “vanilla” system—there is always a need to extend, integrate, or customize behavior. This is where Oracle Fusion’s extensibility framework becomes essential.

From my consulting experience across multiple ERP and HCM implementations, extensibility is not just about adding fields or writing integrations—it’s about doing it without breaking SaaS upgrade compatibility, especially in release cycles like 26A and beyond.

This handbook-style guide will walk you through the practical, implementation-focused approach to Oracle Fusion Applications extensibility.

What is Oracle Fusion Applications Development and Extensibility?

Oracle Fusion Applications extensibility refers to the ability to customize and extend standard SaaS functionality without modifying core code.

Unlike legacy systems (EBS, PeopleSoft), where customization meant heavy coding, Fusion provides low-code and pro-code extensibility frameworks such as:

• Application Composer
• Page Composer
• Visual Builder Studio (VBS)
• Oracle Integration Cloud (Gen 3)
• BI Publisher (BIP)
• Fast Formulas
• REST APIs & SOAP Web Services

Key Principle:

“Extend, don’t customize the core.”

This ensures your system remains upgrade-safe, which is critical in quarterly releases like 26A, 26B, etc.

Why Extensibility is Critical in Oracle Fusion Cloud

In real projects, extensibility is required due to:

Key Extensibility Tools in Oracle Fusion

1. Application Composer

Used for:

• Creating custom objects
• Adding fields to standard objects
• Writing Groovy scripts

2. Page Composer

Used for:

• UI personalization
• Role-based layout changes

3. Visual Builder Studio (VBS)

• Modern UI extensions
• Redwood UX-based customization

4. Oracle Integration Cloud (OIC Gen 3)

• Integration platform
• Event-driven architecture

5. BI Publisher (BIP)

• Custom reports
• RTF and XML templates

6. Fast Formulas

• Business logic implementation
• Used heavily in HCM and Payroll

Real-World Integration Use Cases

Use Case 1: Custom Employee Onboarding Extension

A client wanted:

• Additional onboarding fields
• Auto document generation

Solution:

• Application Composer → custom fields
• BIP → offer letter generation
• OIC → integration with document storage

Use Case 2: Invoice Approval Automation

Client requirement:

• Approval based on invoice amount and supplier category

Solution:

• BPM rules configuration
• Fast Formula for validation logic
• OIC integration for external approval system

Use Case 3: Third-Party Payroll Integration

Requirement:

• Sync employee data with external payroll

Solution:

• OIC Gen 3 REST integration
• Scheduled orchestration
• Error handling using fault policies

Architecture / Technical Flow

A typical extensibility architecture looks like this:

1. Fusion Application (ERP/HCM/SCM)
2. Extension Layer (Composer / VBS)
3. Integration Layer (OIC Gen 3)
4. External Systems (Payroll, Banking, CRM)

Flow Example:

• Employee created in HCM
• Event triggered
• OIC picks event
• Transforms payload
• Sends to third-party system

Prerequisites for Development and Extensibility

Before implementing extensibility, ensure:

• Access to Sandbox Environment
• Required roles:
  
  • Application Developer
  • Integration Specialist
• Access to:
  
  • OIC Gen 3 instance
  • BI Publisher
• Knowledge of:
  
  • REST APIs
  • Groovy scripting
  • Oracle Fusion data model

Step-by-Step Build Process

Step 1 – Create Sandbox

Navigation:
Navigator → Configuration → Sandboxes

• Create new sandbox
• Enable tools like:
  
  • Application Composer
  • Page Composer

Step 2 – Add Custom Field Using Application Composer

Navigation:
Navigator → Tools → Application Composer

Example:

• Object: Worker
• Add Field: “Employee Category Code”

Field Details:

• Type: Text
• Length: 50
• Required: Yes

Save and Publish sandbox.

Step 3 – Customize UI Using Page Composer

Navigation:
User Menu → Edit Pages → Page Composer

• Add custom field to UI
• Rearrange layout
• Apply role-based visibility

Step 4 – Build Integration in OIC Gen 3

Steps:

1. Create Connection
   
   • REST Adapter
   • Fusion SOAP Adapter
2. Create Integration
   
   • Pattern: App Driven Orchestration
   • Trigger: Employee Creation Event
3. Map Fields
   
   • Source: Fusion payload
   • Target: External API
4. Add Error Handling
   
   • Scope with fault handling

Step 5 – Create BI Publisher Report

Navigation:
Tools → Reports and Analytics

Steps:

• Create Data Model
• Upload XML sample
• Design RTF template
• Generate output (PDF/Excel)

Step 6 – Deploy Using Visual Builder Studio

• Create project
• Clone repository
• Modify UI extension
• Deploy to test environment

Testing the Technical Component

Test Scenario: Employee Integration

Test Steps:

1. Create employee in HCM
2. Trigger integration
3. Monitor in OIC

Expected Results:

• Payload sent successfully
• Response received (200 OK)
• Data available in external system

Validation Checks:

• Field mapping accuracy
• Error handling
• Performance

Common Errors and Troubleshooting

Best Practices for Extensibility

1. Always Use Sandbox

Never make direct changes in production.

2. Avoid Over-Customization

Stick to standard features wherever possible.

3. Use OIC for Integrations

Avoid direct database connections.

4. Maintain Naming Standards

Example:

• Custom fields: XX_
• Integrations: INT_

5. Document Everything

Include:

• Field definitions
• Integration flows
• Error scenarios

6. Plan for Quarterly Updates

Test all extensions before applying updates like 26A.

Real Consultant Tips

• Always validate business requirement before extending
• Avoid Groovy unless necessary—prefer configuration
• Use event-driven integrations instead of scheduled jobs where possible
• Monitor OIC dashboards regularly

Frequently Asked Questions (FAQs)

1. What is the difference between customization and extensibility in Oracle Fusion?

Customization modifies core application code (not allowed in SaaS), while extensibility adds features using supported frameworks like Composer, OIC, and VBS.

2. Can we write custom code in Oracle Fusion?

Yes, but limited to:

• Groovy scripts
• Fast Formulas
• VBS extensions

Direct database-level coding is not allowed.

3. Which tool should I use for integrations?

Use Oracle Integration Cloud (Gen 3) for all integrations instead of point-to-point connections.

Summary

The Oracle Fusion Applications Development and Extensibility Handbook is essential for modern consultants working in cloud ERP environments. Unlike traditional systems, Fusion emphasizes:

• Configuration over customization
• Extensibility over modification
• Cloud-safe development practices

By using tools like Application Composer, OIC Gen 3, and Visual Builder Studio, you can deliver scalable, upgrade-safe solutions that meet complex business requirements.

For deeper reference, always consult official Oracle documentation:
https://docs.oracle.com/en/cloud/saas/index.html