Under the application’s Message types, create the two 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 pick file’s filename (Step 7), the notification’s mail fields (Step 9), and the alert subject (Step 10) bind these values, and adapter parameters and mail fields are plain strings: they bind {{…}} tokens but never evaluate a body path.

A failed delivery re-publishes the order payload intact, but promotions are type-qualified, so the exception type needs its own:

Four external parties, four 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.

Both mail ports (Steps 9 and 10) send through it.

Create the table and procedure in your invoicing database; the finance port (Step 8) calls the procedure. BookInvoice loads the mapped invoice JSON with OPENJSON and is idempotent on the invoice number, so a replayed order books once.

CREATE TABLE dbo.InvoiceLedger (
    InvoiceNumber VARCHAR(40)   NOT NULL PRIMARY KEY,
    CustomerId    VARCHAR(40)   NOT NULL,
    Amount        DECIMAL(18,2) NOT NULL,
    Currency      CHAR(3)       NOT NULL,
    BookedAt      DATETIME2     NOT NULL CONSTRAINT DF_IL DEFAULT SYSUTCDATETIME()
);

CREATE OR ALTER PROCEDURE dbo.BookInvoice
    @InvoiceJson NVARCHAR(MAX)
AS
BEGIN
    SET NOCOUNT ON;
    MERGE dbo.InvoiceLedger AS tgt
    USING (
        SELECT invoiceNumber, customerId, amount, currency
        FROM OPENJSON(@InvoiceJson)
        WITH (
            invoiceNumber VARCHAR(40)   '$.invoiceNumber',
            customerId    VARCHAR(40)   '$.customerId',
            amount        DECIMAL(18,2) '$.amount',
            currency      CHAR(3)       '$.currency'
        )
    ) AS src
        ON tgt.InvoiceNumber = src.invoiceNumber
    WHEN NOT MATCHED THEN
        INSERT (InvoiceNumber, CustomerId, Amount, Currency)
        VALUES (src.invoiceNumber, src.customerId, src.amount, src.currency);
END;

Under the application’s Maps, create the map the warehouse port (Step 7) selects. A map is not a file, it is a named resource stored in the platform:

Maps are authored in XSLT 3.0 and run on Saxon HE 12.9. Order-level fields the warehouse needs; if your canonical Order carries line items, iterate $in?lines?* here instead:

<xsl:stylesheet version="3.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <!-- The Order JSON arrives as a string; parse-json() turns it into an XPath 3.1 map -->
  <xsl:template match="/">
    <xsl:variable name="in" select="parse-json(.)"/>
    <xsl:text>ORDER;CUSTOMER;REGION;TOTAL&#10;</xsl:text>
    <xsl:value-of select="string-join((
      $in?orderNumber,
      $in?customer?name,
      $in?region,
      string($in?total)), ';')"/>
    <xsl:text>&#10;</xsl:text>
  </xsl:template>
</xsl:stylesheet>

The finance delivery gets its own map, which reshapes the canonical Order into the invoice shape the booking procedure (Step 3) expects:

<xsl:stylesheet version="3.0"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text"/>
  <xsl:template match="/">
    <xsl:variable name="in" select="parse-json(.)"/>
    <xsl:value-of select="serialize(
      map {
        'invoiceNumber': concat('INV-', $in?orderNumber),
        'customerId': string($in?customer?id),
        'amount': number($in?total),
        'currency': string($in?currency)
      },
      map { 'method': 'json', 'indent': true() })"/>
  </xsl:template>
</xsl:stylesheet>

If the online order intake build already lives in this Application, skip this step: its API Listener and WebOrderToOrder map are the intake. On an empty environment, stand up a minimal edge instead. This walkthrough starts where a canonical Order is already on the bus, so the test rig publishes one directly, no map. Create a receive port WebshopOrders. (The dropdowns can also create types and maps inline; building the dependencies first keeps each dialog a selection.)

Declare the two matching headers that keep this Listener unique on the shared ingress (routing on a shared ingress covers the full rule):

The Step 11 test then posts the canonical sample above to the shared ingress with those two headers.

Create a send port WarehousePickFile on the SFTP Caller, subscribing on {{Message.MessageType}} == "Order".

On the outbound flow, select OrderToPickFile, from Step 4, so the order leaves in the warehouse’s layout.

The Filename wraps the order number in a literal prefix and extension, binding the OrderNumber promotion from Step 1, so the sample order lands as order_SO-10472.csv:

order_{{Promoted.Order.OrderNumber}}.csv

Create a send port FinanceRow on the SQL Caller, subscribing on {{Message.MessageType}} == "Order".

On the outbound flow, select OrderToInvoice, from Step 5, so the procedure receives the invoice shape rather than the raw order.

One row under Input Parameters; the mapped invoice JSON travels whole:

Create an O365 Mail send port AccountManagerMail, subscribing on {{Message.MessageType}} == "Order". No outbound map here: the notification composes straight from the promotions defined on Order in Step 1.

On WarehousePickFile, FinanceRow, and AccountManagerMail, set Exception Message Type, on the port’s General step, to OrderDeliveryFailed, from Step 1.

Create the OpsAlert O365 Mail port subscribing on {{Message.MessageType}} == "OrderDeliveryFailed":

Everything you configure is live the moment you save it, there is nothing to deploy. Start the send ports first, then the receive ports.

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.

Post one test order. In tracking you should see one published Order and three independent deliveries.

Stop the warehouse SFTP server and post another order: file delivery suspends and alerts, the database row and the email still complete, that independence is the whole point. Replay the held delivery when the server is back.