Custom EFT Payment Approval for Specific Banks

When managing multi-bank payouts, the goal is to maintain a clean flow of funds while ensuring strict internal controls. A common challenge arises when one banking partner, such as Wells Fargo, provides a stable external approval workflow, while another, like Regions Bank, requires the internal system of record to act as the gatekeeper.

The requirement is clear: trigger a NetSuite approval workflow only when a payment is destined for Regions Bank, while allowing Wells Fargo payments to proceed without that extra layer of friction. Because the Electronic Bank Payments (EBP) bundle's native batch approval applies to all payments, it is often rejected by leadership as it creates unnecessary bottlenecks for other accounts.

The Challenge of Conditional Approval Logic

The difficulty lies in the fact that standard NetSuite workflows often trigger based on the record type (e.g., vendorbill or payment) rather than specific criteria within the payment's metadata. If you enable a standard approval workflow on the Payment record, every single payment will require an approval, regardless of the bank.

To solve this without enabling global batch approvals, you must implement a logic gate that identifies the specific bank or EFT template being used. This requires evaluating the transaction's data before it is finalized and submitted for payment.

Solution 1: Using Standard Approval Routing with Bank Records

Before jumping into custom scripting, it is important to verify if the standard NetSuite functionality can handle this. Many organizations attempt to build complex logic when a native configuration exists.

In NetSuite, the Bank record and the Electronic Bank Payments (EBP) bundle often interact with specific bank accounts. If you are using the EBP bundle, each Bank account in NetSuite is associated with a specific bank's profile.

1. Navigate to Setup > Accounting > Bank Accounts.
2. Identify the specific account for Regions Bank.
3. Check if your organization's internal controls allow for a "Bank-Specific" approval workflow.

However, if the standard Approval Routing is too broad (applying to all accounts), you must move toward a more granular approach using Custom Fields and Workflow Actions.

Solution Grouping: Identifying the Target Bank

To implement a conditional approval, you first need to ensure that the "Bank" or "EFT Template" is being captured correctly on the transaction. If you are using a custom EFT template, that template should ideally be linked to a specific Bank Account record.

If the user selects a "Regions Bank" template, the transaction will carry that bank's unique ID. We can use this as our trigger.

Step-by-Step Configuration for Conditional Workflow

To achieve a "selective" approval process, follow these steps:

1. Create a Custom Field: If you aren't already tracking the specific bank via a custom field on the payment, create one.

• Navigate to Customization > Lists > New Record Type (or use a custom body field on the payment record).
• Field ID: custbody_bank_approval_required (Example)

2. Map the Template: Ensure that when a Regions Bank EFT template is selected, it populates this field.
3. Workflow Setup:

• Navigate to Customization > Customization > SuiteFlow Actions (Workflows).
• Create a new Workflow.
• Release Status: Released.
• Subtype: Transaction.
• Records to Create: Payment.

4. Conditioning the Workflow:

• In the Release Criteria, set the condition to: Field: [Region Bank Template/Account] is [Regions Bank ID].
• This ensures the workflow only triggers for the specific bank requested.

Solution 2: SuiteScript for Granular Control

If the standard Workflow engine cannot handle the specific logic (e.g., if you need to check multiple conditions across different banks or complex nested logic), a User Event Script is the most stable way to handle this.

By using a beforeSubmit script, you can intercept the transaction as it is being saved. The script can check if the bank or template belongs to Regions Bank and, if so, set a "Pending Approval" status or trigger a specific internal action.

However, since the goal is to enable an approval process for some and not others, a common approach is to use a User Event Script to set a "Require Approval" flag on the record.

/**
 * @NApiVersion 2.1
 * @NScriptType UserEventScript
 */
define(['N/record', 'N/log'], (record, log) => {
    /**
     * This script checks if the payment is for Regions Bank.
     * If it is, it can set a custom field or trigger logic 
     * that marks the payment as requiring approval.
     */
    const beforeSubmit = (scriptContext) => {
        // Only run on Create or Edit of a Payment record
        if (scriptContext.UserEventType !== Entry.Type.CREATE && 
            scriptContext.UserEventType !== Entry.Type.DELETE) {
            // Note: You might want to exclude specific types here
        }

        const newRecord = scriptContext.newRecord;
        
        // Get the Bank Account or a custom field identifying the bank
        // Replace 'custbody_bank_name' with your actual field ID
        const bankName = newRecord.getValue({ fieldId: 'custbody_bank_name' });

        // Logic to check for Regions Bank
        const regionsBankName = "Regions Bank";

        if (bankName === regionsBankName) {
            // If it is Regions Bank, we want to ensure the approval process is triggered.
            const recordId = newRecord.id;
            log.audit({ title: 'Region Bank Detected', details: 'Applying approval logic for ID: ' + recordId });
            
            // Example: Set a custom field that triggers the Workflow
            // record.setValue({ fieldId: 'custbody_require_approval', value: true });
        } else {
            // For Wells Fargo or others, do nothing.
            log.debug({ title: 'Other Bank Detected', details: 'No special approval logic applied.' });
        }

        return action.SUCCESS;
    };

    /**
     * Note: In a real implementation, you would return the action object 
     * or handle the logic to ensure the record is saved correctly.
     */
    return {
        beforeSubmit: (scriptContext) => {
            const newRecord = scriptContext.newRecord;
            const bankName = newRecord.getValue({ fieldId: 'custbody_bank_name' });

            if (bankName === "Regions Bank") {
                // Logic to handle approval requirement
                log.audit({ title: 'Region Bank Detected', details: 'Approval logic triggered.' });
            }
        }
    };
});

Refining the Logic with SuiteQL

If you need to audit these payments or generate a report on which payments are currently awaiting approval specifically for Regions Bank, you can use SuiteQL. This is useful for the finance team to see the status of pending files.

SELECT 
    id, 
    tranid, 
    entity, 
    amount, 
    custbody_bank_name 
FROM 
    transaction_payment 
WHERE 
    custbody_bank_name = 'Regions Bank' 
    AND status = 'Pending Approval'

To require approval only for Regions Bank, move away from global batch approvals toward conditional logic. Identify the bank or EFT template on the transaction record, and hold only the payments that need it. This keeps a fast workflow for banks like Wells Fargo while satisfying audit requirements for Regions Bank.