Mastering SFCC Pipelines…

Mastering SFCC Pipelines: The “Legacy” Engine That Still Runs the Show If you’ve recently entered the Salesforce B2C Commerce (SFCC) ecosystem, you’re likely working with SFRA and Controllers. But step into a project that’s been around for more than 5-6 years, and you’ll find yourself staring at a visual flow of boxes and arrows: The Pipelines.

While Salesforce officially moved away from Pipelines in favor of JavaScript Controllers, thousands of high-revenue retail sites still rely on them. As a Senior Developer, knowing how to navigate (and fix) them is a rare and valuable skill.

What Exactly Are Pipelines? Think of a Pipeline as a visual representation of a business process. Instead of reading lines of code to understand the checkout flow, you look at a flowchart in UX Studio.

A Pipeline consists of:

Start Nodes: The entry points (Public or Call nodes).

Pipelets: Predefined building blocks that perform specific tasks (e.g., UpdateShippingAddress, CalculateBasket).

Script Nodes: Where the custom logic lives (using .ds files - Demandware Script).

Transitions: The logic paths (ok, error, next).

The Infamous Pipeline Dictionary (pd) The biggest hurdle for “modern” devs is the Pipeline Dictionary. In Controllers, you pass variables through function arguments. In Pipelines, everything is stored in a global-like state called the pd.

Pro Tip: If you can’t find where a variable is coming from, check the “Dictionary Output” of the previous Pipelet. Debugging Pipelines is 90% tracing who put what into the pd.

Why Should You Care in 2026? Maintenance of Legacy Giants: Many Tier-1 retailers haven’t migrated to SFRA because their Pipeline-based SiteGenesis is heavily customized and stable.

Performance Integration: Sometimes, calling a sub-pipeline is still faster for certain legacy jobs than wrapping everything in a Controller.

The “Hybrid” Architect: Understanding how a Controller can call a Pipeline (via Pipelet(‘Script-Call’).execute(…)) makes you the bridge between the old and the new world.

Common Pitfalls to Avoid The “Spaghetti” Flow: Avoid creating Pipelines that look like a spider web. If you have more than 10 nodes, it’s time to move logic into a Script Node or a Sub-pipeline.

Transaction Handling: Pipelines handle transactions differently. Be careful with Transaction.begin() and commit() inside Script Nodes when they are part of a larger Pipeline flow.

The .ds vs .js Confusion: Remember that .ds (Demandware Script) is the older brother of modern SFCC JS. It’s more restrictive but essential for Pipeline Script Nodes.

Final Thoughts Pipelines are not “dead”—they are “classic.” Being able to debug a broken COPlaceOrder pipeline in the middle of a Black Friday sale is what separates a Junior from a Lead Developer.

If you find yourself in a project with *.xml files in the pipelines folder, don’t panic. Embrace the visual flow. It’s just logic in a different costume.

Visual Logic meets Scripting

When a standard Pipelet isn’t enough, we use a Script Node. This is where you connect a visual Pipeline to a .ds file. Here is a classic example of how we handle input/output using the Pipeline Dictionary:

/**
* Demandware Script File - CalculateCustomDiscount.ds
* This script calculates a loyalty discount based on the 'pd' input.
*
* @input  Basket : dw.order.Basket  The current customer basket
* @input  DiscountRate : Number      The percentage to discount
* @output DiscountAmount : Number    The calculated value to be put back in 'pd'
*/

importPackage( dw.system );
importPackage( dw.util );

function execute( pdict : PipelineDictionary ) : Number {
    // 1. Accessing inputs from the Dictionary
    var basket : dw.order.Basket = pdict.Basket;
    var rate : Number = pdict.DiscountRate;

    if (!basket || !rate) {
        return PIPELET_ERROR;
    }

    // 2. Business Logic
    var total : Number = basket.getTotalGrossPrice().getValue();
    var amount : Number = total * (rate / 100);

    // 3. Mapping the result back to the Dictionary Output
    pdict.DiscountAmount = amount;

    return PIPELET_NEXT;
}