Under the application’s Message types, create the three types this flow routes on. A message type is a name plus a format, no schema required:

Promotions live on the message type, so add them while you are here. The reconcile port’s parameters (Step 7) bind these values, and adapter parameters are plain strings: they bind promotions, not body paths.

Three external parties, three credentials. Under the application’s Authentications, the dialog asks for a Name, the Adapter it pairs with, and a Definition, the credential shape that adapter offers, with the Application preset; the Definition decides the config section that follows.

Create the table and procedure in the invoice database; the reconcile port (Step 7) calls the procedure. An unknown invoice THROWs, that is the per-record failure the tutorial relies on, raising SettlementFailed for that one transaction while the rest post. Matching on the payment reference keeps it idempotent under replay.

CREATE TABLE dbo.Invoices (
    InvoiceNumber VARCHAR(40)   NOT NULL PRIMARY KEY,
    Status        VARCHAR(20)   NOT NULL CONSTRAINT DF_Inv_St DEFAULT 'Open',
    PaidAmount    DECIMAL(18,2) NULL,
    PaymentRef    VARCHAR(40)   NULL,
    PaidOn        DATE          NULL
);

CREATE OR ALTER PROCEDURE dbo.ReconcilePayment
    @PaymentRef    VARCHAR(40),
    @InvoiceNumber VARCHAR(40),
    @Net           DECIMAL(18,2),
    @PaidOn        DATE
AS
BEGIN
    SET NOCOUNT ON;
    IF NOT EXISTS (SELECT 1 FROM dbo.Invoices WHERE InvoiceNumber = @InvoiceNumber)
        THROW 50001, 'Unknown invoice for settlement', 1;

    -- Idempotent: a replayed payment with the same ref changes nothing
    UPDATE dbo.Invoices
    SET Status = 'Paid', PaidAmount = @Net,
        PaymentRef = @PaymentRef, PaidOn = @PaidOn
    WHERE InvoiceNumber = @InvoiceNumber
      AND (PaymentRef IS NULL OR PaymentRef <> @PaymentRef);
END;

Under the application’s Pipeline components, create the disassembler SettlementCsvDisassembler: one message per data row, each stamped with a file id derived from the row’s paid_on date, read from the file itself rather than configured (components are data-driven), so a transaction can be traced back to its batch. Classification (SettlementTransaction) happens on each outgoing message.

The provider’s nightly settlement CSV as it downloads:

payment_ref,invoice_no,gross,fee,net,paid_on
PSP-771202,INV-20391,250.00,4.85,245.15,2026-06-04
PSP-771203,INV-20402,89.90,1.92,87.98,2026-06-04
PSP-771204,INV-20377,1180.00,21.10,1158.90,2026-06-04

One debatched SettlementTransaction as the splitter publishes it:

{
  "paymentRef": "PSP-771202",
  "invoiceNumber": "INV-20391",
  "gross": 250.00,
  "fee": 4.85,
  "net": 245.15,
  "paidOn": "2026-06-04",
  "fileId": "settlement_2026-06-04"
}

using System.Text.Json;
using CC.Art2link.Pipelines.Domain.Models.PipelineComponents;

public sealed class SettlementConfig
{
    // No per-message values here: the file id is derived from the rows.
}

public sealed class SettlementCsvDisassembler
    : PipelineComponentBase<SettlementConfig>
{
    public override string Name => "SettlementCsvDisassembler";

    protected override Task<PipelineComponentOutput> ExecuteAsync(
        PipelineComponentInput input,
        SettlementConfig config,
        CancellationToken cancellationToken)
    {
        try
        {
            var lines = input.Body
                .Split('\n')
                .Select(l => l.TrimEnd('\r'))
                .Where(l => l.Length > 0)
                .ToList();

            var messages = new List<PipelineMessage>();
            foreach (var line in lines.Skip(1))   // skip header row
            {
                var c = line.Split(',');
                var json = JsonSerializer.Serialize(new
                {
                    paymentRef    = c[0],
                    invoiceNumber = c[1],
                    gross         = decimal.Parse(c[2]),
                    fee           = decimal.Parse(c[3]),
                    net           = decimal.Parse(c[4]),
                    paidOn        = c[5],
                    fileId        = $"settlement_{c[5]}"   // from paid_on
                });
                messages.Add(new PipelineMessage
                {
                    Body        = json,
                    MessageType = "SettlementTransaction"
                });
            }

            return Task.FromResult(new PipelineComponentOutput
            {
                Success = true, Messages = messages
            });
        }
        catch (Exception ex)
        {
            return Task.FromResult(new PipelineComponentOutput
            {
                Success      = false,
                ErrorMessage = $"SettlementCsvDisassembler: {ex.Message}",
                Exception    = ex
            });
        }
    }
}

Create the Scheduler receive port SettlementClock; its tick is what wakes the fetch port (Step 6).

Create a two-way SFTP Caller send port SettlementFetch with the download command against the drop directory, fetching everything in it: the provider writes exactly one dated file there each night (settlement_2026-06-04.csv), so the fixed directory is the stable part of the convention, not the filename. Subscription: {{Config.PortName}} == "SettlementClock". (The dropdowns can also create types and components inline; building the dependencies first keeps each dialog a selection.)

Set Authentication to ProviderSftp, from Step 2.

The fetched file rides back as the response and re-enters the bus through the port’s Response stages: set Message Type Fallback to SettlementFile, from Step 1, then select the SettlementCsvDisassembler, from Step 4, to debatch it.

Create a send port ReconcilePayment on the SQL Caller, one-way, calling the procedure from Step 3. Subscription: {{Message.MessageType}} == "SettlementTransaction".

Set Authentication to InvoiceDbSql, from Step 2.

The procedure’s four values go under Input Parameters, one key/value row each, binding the promotions defined on SettlementTransaction in Step 1:

On both send ports, SettlementFetch and ReconcilePayment, set Exception Message Type to SettlementFailed, from Step 1.

Create the OpsAlert O365 Mail port for finance operations subscribing on {{Message.MessageType}} == "SettlementFailed":

Everything you configure is live the moment you save it, there is nothing to deploy. Start the send ports first, ReconcilePayment, OpsAlert and SettlementFetch, then the receive port SettlementClock.

Set Tracking to Enabled + Body on every port the flow touches, so you can walk each run step by step, with its message body, in tracking.

Stage a test file with a handful of transactions, one of them referencing a non-existent invoice, and trigger the tick. To avoid waiting for the 06:00 window, temporarily set SettlementClock to Repeat Every 1 / Minutes, then restore the nightly window once the test passes.

In tracking: one fetch, N published transactions, N−1 successful reconciliations, and exactly one SettlementFailed alert for the mismatch. Fix the invoice and replay just that record.