FBDI project accounting data load fails due to unmapped project types from legacy system

We’re migrating project data from our legacy project management system to Oracle Fusion Cloud Project Accounting (23B) using FBDI templates. The upload consistently fails with validation errors related to project type mappings that don’t exist in Oracle’s configuration.

FBDI error log:


Invalid Project Type 'INTERNAL_DEV' for project PRJ-2024-001
Project Type must exist in PJF_PROJECT_TYPES_VL

Our legacy system has 18 custom project types like INTERNAL_DEV, EXTERNAL_CONSULTING, R&D_INNOVATION, CLIENT_BILLABLE, etc. We’re migrating 450 active projects across these types. The FBDI template validation fails because Oracle doesn’t recognize these legacy type codes.

We’ve verified the FBDI template structure matches Oracle’s specification, and other fields like project number and name validate correctly. The issue is specifically with project type mapping. Do we need to configure Oracle’s project types to match our legacy types before the FBDI load, or should we map our legacy types to Oracle’s standard project types during ETL?

Let me provide you with a comprehensive solution covering all three critical aspects:

1. Project Type Mapping Strategy:

First, analyze your 18 legacy project types and map them to Oracle’s standard project types and classes:

Legacy to Oracle Project Type Mapping:


Legacy Type          -> Oracle Type  | Oracle Class
---------------------------------------------------
INTERNAL_DEV        -> Internal      | Development
EXTERNAL_CONSULTING -> Contract      | Consulting
R&D_INNOVATION      -> Internal      | Research
CLIENT_BILLABLE     -> Contract      | Client Services
CAPITAL_PROJECT     -> Capital       | Infrastructure
MAINTENANCE_SUPPORT -> Internal      | Support
GRANT_FUNDED        -> Grant         | External Funding

Create a mapping table for your ETL transformation:

CREATE TABLE project_type_mapping (
  legacy_project_type VARCHAR2(50),
  oracle_project_type VARCHAR2(30),
  oracle_project_class VARCHAR2(30),
  billing_enabled VARCHAR2(1),
  capitalization_flag VARCHAR2(1),
  description VARCHAR2(240)
);

INSERT INTO project_type_mapping VALUES
('INTERNAL_DEV', 'Internal', 'Development',
 'N', 'N', 'Internal development projects'),
('CLIENT_BILLABLE', 'Contract', 'Client Services',
 'Y', 'N', 'Billable client projects'),
('CAPITAL_PROJECT', 'Capital', 'Infrastructure',
 'N', 'Y', 'Capital asset projects');

2. FBDI Template Validation Requirements:

Pre-Migration Setup in Oracle Fusion:

Before FBDI load, complete these configuration steps in order:

Step 1: Set Up Project Types Navigate to: Setup and Maintenance > Search: Manage Project Types

Oracle standard types should already exist:

  • Contract (for billable projects)
  • Internal (for non-billable internal work)
  • Capital (for asset capitalization)
  • Grant (for grant-funded projects)
  • Indirect (for overhead allocation)

Verify these exist and note their exact codes.

Step 2: Create Project Classes Navigate to: Setup and Maintenance > Search: Manage Project Classes

Create classes that represent your business sub-categories:


Class Code    | Class Name        | Project Type
-------------------------------------------------
DEVELOPMENT  | Development       | Internal
RESEARCH     | Research          | Internal
CONSULTING   | Consulting        | Contract
CLIENT_SVCS  | Client Services   | Contract
INFRASTRUCT  | Infrastructure    | Capital
SUPPORT      | Support           | Internal

Step 3: Create Project Templates Navigate to: Projects > Project Templates

Create templates for each type/class combination:

Template: Internal Development Projects

  • Project Type: Internal
  • Project Class: Development
  • Billing Enabled: No
  • Capitalization: No
  • Default Organization: Your Dev Org
  • Default Manager Role: Development Manager

Template: Client Billable Projects

  • Project Type: Contract
  • Project Class: Client Services
  • Billing Enabled: Yes
  • Capitalization: No
  • Default Billing Method: Time and Materials
  • Default Invoice Grouping: By Project

FBDI Template Structure:

Your FBDI CSV must include these columns:


PROJECT_NUMBER,PROJECT_NAME,PROJECT_TYPE,PROJECT_CLASS,
TEMPLATE_NAME,ORGANIZATION_NAME,PROJECT_MANAGER,
START_DATE,FINISH_DATE,BILLING_ENABLED_FLAG

Example FBDI record:

PRJ-2024-001,Customer Portal Development,Internal,Development,
Internal Dev Template,IT Operations,john_smith,
2024-01-15,2024-12-31,N

3. Project Setup Configuration:

Complete ETL Transformation Logic:

-- ETL query to transform legacy to Oracle format
SELECT
  lp.project_number,
  lp.project_name,
  ptm.oracle_project_type as project_type,
  ptm.oracle_project_class as project_class,
  CASE
    WHEN ptm.oracle_project_type = 'Internal'
      THEN 'Internal Dev Template'
    WHEN ptm.oracle_project_type = 'Contract'
      THEN 'Client Billable Template'
    WHEN ptm.oracle_project_type = 'Capital'
      THEN 'Capital Project Template'
    ELSE 'Default Project Template'
  END as template_name,
  lp.organization_name,
  lp.project_manager,
  TO_CHAR(lp.start_date, 'YYYY-MM-DD') as start_date,
  TO_CHAR(lp.completion_date, 'YYYY-MM-DD') as finish_date,
  ptm.billing_enabled as billing_enabled_flag
FROM legacy_projects lp
JOIN project_type_mapping ptm
  ON lp.legacy_type = ptm.legacy_project_type
WHERE lp.status = 'ACTIVE'

Validation Before FBDI Load:

Run these checks before generating your FBDI file:

-- Verify all project types are mapped
SELECT DISTINCT legacy_project_type
FROM legacy_projects
WHERE legacy_project_type NOT IN (
  SELECT legacy_project_type
  FROM project_type_mapping
);

-- Check for orphaned projects
SELECT project_number, legacy_project_type
FROM legacy_projects
WHERE legacy_project_type IS NULL
   OR TRIM(legacy_project_type) = '';

-- Validate date ranges
SELECT COUNT(*)
FROM legacy_projects
WHERE start_date > completion_date
   OR start_date > SYSDATE;

FBDI Load Process:

  1. Generate FBDI File:

    • Run ETL transformation query
    • Export to CSV with exact column headers
    • Validate CSV format (no extra spaces, proper delimiters)
  2. Upload via FBDI:

    • Navigate to: Tools > File Import and Export
    • Select: Project Import
    • Upload your CSV file
    • Monitor the import process
  3. Review Import Results:

    • Check import log for errors
    • Note any rejected records
    • Verify successful import count matches expected

Post-Load Configuration:

After successful FBDI load, complete these additional configurations:

A. Set Up Billing Rules (for Contract projects):


Navigate to each Contract project:
- Projects > Search Projects > Select Project
- Billing tab > Set up billing rules
- Configure invoice formatting
- Assign billing resources

B. Configure Approval Workflows:


Setup and Maintenance > Manage Project Approval Rules
- Create approval rules by project type/class
- Assign approvers based on project attributes
- Set up notification templates

C. Set Up Project Reporting:


BI Publisher > Project Reports
- Create custom reports by project class
- Add filters for legacy project type (store in DFF)
- Schedule regular distribution

Maintaining Legacy Type Information:

To preserve legacy project type for reporting:

  1. Create Descriptive Flexfield:

    • Setup and Maintenance > Manage Project Descriptive Flexfields
    • Add segment: LEGACY_PROJECT_TYPE
    • Make it required and displayed
  2. Include in FBDI Load:

    • Add DFF column to FBDI template
    • Populate with legacy type code
    • Use for custom reports and filters

Troubleshooting Common Issues:

Issue: Project Type Not Found


Solution: Verify exact spelling and case
Query: SELECT project_type_code
       FROM pjf_project_types_vl;

Issue: Template Not Found


Solution: Check template name exactly matches
Query: SELECT template_name
       FROM pjf_project_templates_vl;

Issue: Invalid Project Class for Type


Solution: Verify class is valid for the type
Query: SELECT pt.project_type_code, pc.class_code
       FROM pjf_project_types_vl pt,
            pjf_project_classes_vl pc
       WHERE pc.project_type_id = pt.project_type_id;

Complete Migration Checklist:

  • [ ] Analyze 18 legacy project types
  • [ ] Create mapping to Oracle types/classes
  • [ ] Set up project classes in Oracle
  • [ ] Create project templates
  • [ ] Build ETL transformation with mapping
  • [ ] Add legacy type DFF for reference
  • [ ] Generate FBDI CSV with transformed data
  • [ ] Validate CSV format and data
  • [ ] Upload via FBDI import
  • [ ] Review import logs and fix errors
  • [ ] Verify project configurations
  • [ ] Set up billing rules for Contract projects
  • [ ] Configure approval workflows
  • [ ] Test end-to-end project processes
  • [ ] Create custom reports by project class

By following this comprehensive approach, your project type mapping will be clean, your FBDI template will validate successfully, and your Oracle project setup will maintain the business classifications you need while leveraging Oracle’s standard configuration.


This draft is based on general Oracle Fusion Cloud knowledge. It has not been verified against your specific version and environment. Practitioners: verify the steps and share your experience below.

You need to set up your project types in Oracle Fusion before attempting the FBDI load. FBDI won’t create project types for you - they must exist in the system first. Navigate to Setup and Maintenance, search for ‘Manage Project Types’, and create project types that match your legacy classifications. You can either recreate your exact legacy types or map them to Oracle’s standard project types during your ETL transformation.

I recommend mapping to Oracle’s standard project types rather than recreating all your custom types. Oracle has predefined project types like Capital, Contract, Indirect, Grant, etc. that cover most business scenarios. Review your 18 legacy types and categorize them into Oracle’s standard types based on business rules. For example, your INTERNAL_DEV and R&D_INNOVATION might both map to Oracle’s ‘Internal’ project type. Your CLIENT_BILLABLE could map to ‘Contract’ type. This approach reduces custom configuration and makes future upgrades easier. Create a mapping table in your ETL that translates legacy types to Oracle types before generating the FBDI file.

Tested this on Oracle Fusion Cloud 23D with 18 legacy project types, and mapping CAPITAL_PROJ to the Contract class with correct FBDI project type lookups resolved our data load failures completely.

That makes sense. I reviewed Oracle’s standard project types and can map most of our legacy types to them. However, we have specific billing rules and approval workflows tied to our legacy project types. If we consolidate to fewer Oracle types, will we lose that granularity? How do we maintain our business-specific classifications?

Use Oracle’s project classes in addition to project types to maintain granularity. Project type is the high-level classification (Contract, Internal, Capital), while project class lets you add sub-classifications. You can create custom project classes like ‘R&D Innovation’, ‘Client Billable’, etc. under the appropriate project type. This gives you the business granularity you need for reporting and workflow rules while still using Oracle’s standard project types. Your FBDI template should include both PROJECT_TYPE and PROJECT_CLASS columns. Set up your project classes in ‘Manage Project Classes’ before the data load.

Also consider using project templates to standardize configurations by project type and class combinations. Once you’ve defined your project types and classes, create templates that include the appropriate billing rules, approval workflows, and default settings for each combination. During migration, you can reference these templates in your FBDI load, which will automatically apply the correct configuration to each project. This is more maintainable than setting up individual rules for each project during migration.

The template approach sounds promising. So my migration strategy would be: 1) Set up project types and classes in Oracle, 2) Create templates with appropriate configurations, 3) Map legacy types to Oracle types/classes in ETL, 4) Reference templates in FBDI load. Is there a specific order for setting up the templates versus running the FBDI load?