Designing the Solution Workstream in the Explore Phase

Preparing for Data Load and Defining a Strategy

Objective

After completing this lesson, you will be able to execute a structured data load preparation workstream during the Explore phase by assessing legacy data quality, completing field mappings, staging data, and validating templates — so that mock load cycles can begin in the Realize phase once Iteration 1 (IT1) foundation configuration is complete.

Data Load Preparation

Data quality issues are one of the leading causes of implementation delays, go-live failures, and post-cutover rework. A system can be perfectly configured and still fail at go-live if the data loaded into it is incomplete, inaccurate, or mis-sequenced.

Data load preparation is not a one-time event. It is iterative and tightly linked to scope, configuration, and target data design.

What is Data Load Preparation?

Data load preparation is an iterative workstream that begins as soon as in-scope objects are identified. The goal is to prepare clean, mapped, and validated data that can be loaded reliably into SAP SuccessFactors templates.

What are Guiding Principles of Data Load Preparation?

  • Start early to avoid project delays caused by late data cleansing or incomplete mappings.

  • Use configuration-driven templates and align data preparation to the target SAP SuccessFactors data model.

  • Validate repeatedly: sample loads, error handling, and business-rule checks reduce rework before cutover.

What is the Core Value Proposition of the Data Load Preparation Workstream?

It translates legacy information into a controlled load approach that is ready for testing and production use.

What is the Purpose and Expected Output of the Data Load Preparation Workstream?

Purpose

Prepare legacy data so it can be loaded accurately into SAP SuccessFactors with minimal rework and reduced project risk.

Delivery Principle

Begin preparation as soon as in-scope objects are identified and refine the approach iteratively as the configuration matures.

Expected Output

Cleaned source files, field mappings, client-specific working files, validation evidence, and a sequenced load plan.

With the purpose and guiding principles of data load preparation established, the first step in putting those principles into practice is a thorough assessment of the legacy data that will be migrated.

Assessment and Cleansing

Pre-Preparation Assessment

Assessment is the first control point in the data migration workstream. The team needs a realistic view of quality and volume before creating mappings or promising load dates.

Without this, mapping assumptions can be wrong, load timelines can be unrealistic, and cleansing work that should have started in the Explore phase gets pushed dangerously close to cutover.

Four key components of the pre-preparation assessment stage in the data load preparation workstream are as follows:

Current-System Data Audit

  • Review the legacy data that will be migrated for relevance, completeness, and business value.

  • Identify outdated objects, duplicate records, and information that should be archived instead of loaded.

Volume and Complexity

  • Expected data volumes for each entity or module.

  • Likely load duration for each entity or module.

Data Quality Evaluation

  • Assess inaccuracies, duplicates, obsolescence, and formatting inconsistencies in source data.

  • Highlight data-quality hotspots early so cleansing work can begin before mock loads.

Assessment Outputs

  • Audit findings.

  • Cleansing backlog.

  • Initial migration timing assumptions.

Data Mapping and Design

Template loading depends on a good target design. Field mappings must be reviewed with both the business team and configuration leads because what gets configured in the system determines what the template expects.

The key components of data mapping and design are as follows:

Source-to-Target Design

  • Identify the source systems and objects needed for the implementation scope.

  • Understand the target SAP SuccessFactors data model for the relevant modules and entities.

Field Mapping Documentation

Document source fields, target fields, rules, defaults, and ownership in a structured mapping workbook.

Transformation Planning

  • Define extraction, creation, and transformation logic required to fit SAP SuccessFactors template constraints.

  • Include rules for date formatting, code conversion, and target picklist alignment.

Design Outcome

Approved mappings and a clear transformation approach for each in-scope object.

Data Extraction and Staging Process

With source-to-target mappings approved and transformation logic defined, the next step is to move the data through a controlled operational pipeline.

Source data moves through controlled steps before it is placed into SAP SuccessFactors load templates.

Each step is a control point designed to reduce avoidable errors before template population begins.

Image shows the four steps in the operational pipeline

The four steps in the operational pipeline are as follows:

  1. Extract
    • Pull data from source systems.

    • Use approved extraction procedures.

  2. Cleanse
    • Remove obsolete objects that should not be migrated.

    • Apply omission rules to eliminate unnecessary or duplicate records.

  3. Validate
    • Check format and constraints against SAP SuccessFactors template requirements.

    • Confirm field readiness to ensure values are structured correctly before staging.

  4. Stage
    • Prepare the cleansed files.

    • Data is now ready for template load.

Template Preparation

With source data extracted, cleansed, and staged, the team is now ready to move into template preparation. The template preparation is configuration driven. This means that files should be refreshed as design changes. Working files become the operational control file for the migration team.

The three core activities that make up the template preparation stage of the data load workstream are as follows:

Template Download

Download data-load templates from Admin Center because template structure depends on current system configuration.

Client Working Files

Create client-specific "working files" to support validation, tracking, and iterative updates.

Mandatory and Optional Fields

Highlight required fields, validate them through sorting and filtering, and then configure optional columns based on business requirements.

Data Validation and Testing

With mandatory fields confirmed and mappings approved, the Explore-phase team validates the templates and process flow — not the full data load. Full end-to-end validation using loaded data occurs in the Realize phase through mock load cycles.

Validation is both technical and business-oriented.

Integrity Checks (Explore — Template Level)

  • Validate completeness and accuracy of template files with Excel-based controls or equivalent validation logic
  • Confirm all mandatory fields and key identifiers are populated correctly in the template

Business-Rule Checks (Explore — Template Level)

Verify template compliance with configured business rules, picklists, and reference values

Sample Template Tests (Explore — Unit Level Only)

  • Execute small sample loads to prove the templates and process flow are technically sound
  • Capture uploaded, failed, and corrected records as part of an error-resolution process

Validation Outcome (Explore)

A repeatable template load, defect-correction, and reimport process — ready to be exercised at scale during Realize-phase mock load cycles.

Note

Sample template tests in Explore validate that the files and process work technically. They are not mock load cycles. True mock load cycles — which exercise the full extract → transform → validate → load → reconcile sequence at increasing data volumes (25% → 80% → 100%) — begin in the Realize phase, after IT1 foundation objects are configured and executed.

Load Sequencing Plan

The order in which data is loaded into SAP SuccessFactors is not a preference. It is a system constraint. Foundation data and reference values must be stable and present in the system before employee and historical records can be loaded successfully.

Load orderModule / EntityDependencies
Phase 1Foundation objects and picklistsSystem configuration complete
Phase 2Employee master dataFoundation objects loaded
Phase 3Position data (if applicable)Employee data loaded
Phase 4Historical data & formsMaster data complete

The table describes the four-phase load order:

Phase 1 — Foundation Objects and Picklists

Organizational units, job classifications, and picklist values must be loaded first. Every subsequent entity references these objects by ID, so system configuration must be complete before this phase begins.

Phase 2 — Employee Master Data

With foundation objects stable in the system, employee master records can be loaded. These records reference foundation object IDs directly — Phase 1 must be complete or Phase 2 loads will fail.

Phase 3 — Position Data (if applicable)

Position data references employee records and must follow Phase 2. This phase applies only where position management is in scope.

Phase 4 — Historical Data & Forms

This phase represents the most downstream entity in the sequence. Historical records and forms reference master data from Phases 1 and 2 and can only be loaded once that data is complete and validated.

The following figure illustrates why the sequence cannot be arbitrary. Each phase depends on successful completion of the one before it.

The image shows the sequencing dependencies and load logic.

The load order should reflect object dependencies so that downstream entities are not loaded before prerequisite data exists.

Note

Sequencing Plan vs. Sequencing Execution

The load sequencing plan is defined in Explore as part of the migration strategy. The execution of that sequence — actually loading foundation objects, then employee master, then position, then historical data — occurs across mock load cycles in the Realize phase (after IT1 foundation configuration is complete) and during the production cutover in Deploy.

Cutover Rehearsal in Non-Productive Environments

Cutover rehearsal via mock load cycles cannot occur in the Explore phase — the foundation objects (company structure, cost centers, positions) required to receive loaded data are not yet configured. Foundation configuration is built and executed in Iteration 1 (IT1) of the Realize phase. Only after IT1 is complete can meaningful mock load rehearsals begin.

During the Explore phase, the team focuses on planning and preparing for cutover rehearsal — not executing it.

This preparation includes:

Mock Load Scheduling (Planning — Explore)

  • Define the mock load plan, the sequence of events, expected data volumes, and expected duration for each load.

  • Schedule the load window so that business impact is minimized and support resources are available.

Rollback Procedures (Planning — Explore)

Prepare backup, recovery, and contingency steps to be used before major data loads begin in Realize.

Rehearsal Completion Validation Checklist (Planning — Explore)

Create a formal checklist to verify that the mock load will be validated correctly when executed in Realize.

Cutover Rehearsal Output (Explore Deliverable)

Approved schedule, rollback plan, and rehearsal completion validation checklist — ready to be exercised during Realize-phase mock load cycles.

Note

Where Rehearsal Actually Happens

  • Explore Phase: Plan the rehearsal. Prepare the schedule, rollback procedures, and validation checklist.
  • Realize Phase (post-IT1): Execute the mock load cycles. Foundation objects are now configured and can receive data. Each rehearsal exercises the full go-live sequence — extract → transform → validate → load → reconcile — at progressively larger data volumes (25% → 80% → 100% → 95%+ readiness).
  • Deploy Phase: Execute the actual production cutover — freeze the legacy source, run the final load into Production, and issue the go-live decision.

Post-Load Activities

Post-load activities are defined and planned during Explore but executed after each mock load cycle in Realize and after the production cutover in Deploy. These activities close the loop and include:

  • Data Verification: Confirm loaded data is accessible and supports downstream processes (executed after each Realize mock load and after Deploy cutover).

  • User Acceptance Testing: Validate data with business users (executed in Realize).

  • Performance Monitoring: Monitor system performance and data integrity after each load (executed in Realize and Deploy).

The load is only considered complete when the data is verified in the system, accepted by users, and stable from a performance perspective — a state that is achieved through the Realize-phase mock load progression, culminating in the Deploy-phase production cutover.

Readiness Checklist

The Readiness Checklist serves as a practical summary of the minimum conditions that must be met before transitioning from Explore-phase preparation into Realize-phase mock load execution.

Practical readiness checks include:

Preparation Checks (Complete in Explore):

  • Source audit completed

  • Mappings approved

  • Templates refreshed from Admin Center

  • Working files prepared

  • Omission rules documented

Validation Checks (Complete in Explore — Template Level):

  • Mandatory fields validated

  • Sample load passed

  • Errors tracked and corrected

  • Load sequence approved

  • Go-live checklist ready for Realize-phase execution

Note

The team is ready to exit Explore-phase preparation and enter Realize-phase mock load execution only when the Readiness Checklist is complete and IT1 foundation configuration has been executed.

Data Migration Kickoff and Planning

With the minimum readiness conditions confirmed, the team is now positioned to move into formal Data Migration Kickoff and Planning to align on scope, responsibilities, tools, and success criteria that will govern the migration workstream through every phase of the project.

  • Data Migration Kickoff Meeting: This always occurs in the Explore phase. This session covers a review of data migration scope, roles and responsibilities, and the proposed approach and strategy.

  • Data Migration Strategy: Finalize the data migration strategy and obtain formal sign-off from all applicable stakeholders.

  • Data Correction Strategy: Throughout the data migration process, the team will uncover data quality issues that need to be addressed prior to go-live. The leading practice is to correct the data at the source system level as the issues are identified, rather than waiting until cutover. The team should define and agree on the process that will be used to correct the data throughout the project.

  • Data Migration Tools: Identify and align on the tools, technologies, connectors, protocols, and any other resources that will be used to support the migration.

  • Develop Load Plan: Define a load plan that includes load sequence, expected data volumes and estimated load times for each phase.

  • Download Templates for Data Loads: Review and download Foundation and Employee data mapping templates to be used for all data loads.

  • Finalize Success Criteria for all Phases of Data Migration: Define and agree on measurable success criteria for each phase of the migration. Examples include:

    • IT1: Golden records — a representative sample of 100 to 200 employee records.

    • IT2: 75% of total employee data loaded.

    • IT3: 95% of total employee data loaded.

    • Production: 100% of employee data loaded and validated.

Extract and Transform Legacy Data

With the migration scope, tools, and load plan confirmed, the team is now ready to extract and transform legacy data.

Purpose

The purpose of this task is to extract data from legacy systems and transform it into a format suitable for loading into the SAP cloud system.

Successful execution requires a strong understanding of the source system data, extraction and transformation tools, and the required data structure for the target system.

Since multiple data objects may be involved, this task is performed iteratively and in accordance with the data extraction and load plan.

If the data migration is occurring from an SAP System as the source system, then this task is not relevant.

Procedure

  1. Extract the necessary data from the legacy systems using a tool that allows for data manipulation. This tool can be a spreadsheet, a database, or other data transformation software.

  2. Harmonize data from different sources.

  3. Transform the data to conform to the target field attributes by considering the following points:

    1. Add missing values

    2. Remove duplicates or unnecessary data

    3. Structure the data so that it can be easily transferred to the load templates

  4. Create load files based on the SAP SuccessFactors extracted data and load templates.

With legacy data extracted and transformation logic applied, the next step is to cleanse the data.

Perform Data Cleansing Activities

Purpose

To cleanse the legacy data before loading into the SAP target system.

Inaccurate data or inconsistent formatting should be corrected. Unnecessary data should be removed from the legacy data to reduce the volume of data to load and keep the new system free from extraneous data.

Data cleansing should occur on the legacy data as soon as the data migration objects are identified, otherwise this process may become a bottleneck for data migration.

Data that’s populated via integration, such as two-tier systems, should be included in the data assessment and cleansing activities.

Procedure

  1. Review data from the legacy systems that will be migrated during the implementation project for relevancy, quality and completeness. Users of the different data can typically provide the best insight into the data quality.

  2. Delete or identify rules for omitting legacy objects that should not be included in the migration.

  3. Identify data inaccuracies, duplication and obsolescence.

  4. Develop plans to correct data issues in the legacy system.

  5. Develop plans to correct data after extraction.

Case Study: What Pinnacle Industries Did During Data Load Preparation

With Fit-to-Standard workshops underway, Pinnacle Industries simultaneously advanced its data load preparation workstream — recognizing early that data quality issues are one of the leading causes of implementation delays.

Key Activities

  • Audited legacy data across all source systems, identifying that Compensation and Performance data scored lower (75–80%), requiring significant cleansing before mock loads could begin.

  • Documented all source-to-target field mappings, including transformation rules and picklist alignment, reviewed with both business stakeholders and configuration leads.

  • Moved source data through a controlled four-step pipeline — Extract, Cleanse, Validate, and Stage — before populating SAP SuccessFactors load templates.

  • Downloaded and configured data load templates from Admin Center, creating client-specific working files as the operational control files for the migration team.

  • Executed integrity checks, business-rule checks, and sample test loads to validate data before scaling to full volumes.

Outcome

  • Entered the Realize phase with clean, mapped, and validated data files ready for iterative mock loads.

  • Prevented data issues from becoming a bottleneck on the critical path to go-live.

Summary

  • Data load preparation is iterative, beginning as soon as in-scope objects are identified, with the goal of preparing clean, mapped, and validated template files for loading into SAP SuccessFactors during Realize.

  • Early assessment is critical — auditing legacy data for quality, volume, and complexity before creating mappings or committing to load timelines prevents costly delays closer to cutover.

  • Load sequencing is a system constraint — the sequence is designed in Explore (foundation → employee master → position → historical) but executed through Realize-phase mock loads.

  • Success criteria must be defined per iteration — golden records for IT1, 75% employee data for IT2, 95% for IT3, and 100% for production cutover.

  • Cutover rehearsal is planned in Explore but executed in Realize — the mock load schedule, rollback procedures, and rehearsal completion validation checklist are all prepared during Explore, then exercised through iterative mock load cycles in Realize once IT1 foundation objects are configured.

  • Post-load activities — data verification, user acceptance testing, and performance monitoring — are defined in Explore but executed in Realize (after each mock load) and Deploy (after the production cutover).