✔️Validate then Send

Learn the production-ready best practice of validating requests before dispatching, with complete implementation examples in 4 languages.

Overview

The Validate-then-Send pattern is a critical best practice for production integrations:

1. Validate the request structure and data (fast, free, safe)

2. Fix any validation errors

3. Send the real dispatch once validation passes

This two-step approach prevents errors, saves credits, and ensures data quality before external API calls.

Why Validate First?

Benefits

Benefit	Impact
Catch errors early	Before external API calls, before credits charged
Free validation	No credits consumed for validation
Fast feedback	< 100ms response vs 2-10s for real dispatch
No side effects	No records created in external systems
Safe testing	Perfect for development and testing
Better UX	Show validation errors to users before submission

What Validation Checks

Validation performs comprehensive checks without calling external providers:

• ✅ Request structure and required fields

• ✅ Data types and format

• ✅ Template existence and accessibility

• ✅ Provider configuration presence

• ✅ Business logic (amounts, dates, references)

• ✅ Template data schema compliance

• ❌ Does NOT call external provider APIs

• ❌ Does NOT create real records

• ❌ Does NOT charge credits

Prerequisites

• Docs-Dispatcher account with email and password

• At least one provider configured

• Template created in Templater

• Basic understanding of REST APIs

Step 1: Authentication

Dispatcher API uses HTTP Basic Authentication. You'll need your Dispatcher account email and password for all API calls.

Setup Credentials

# Store credentials as environment variables
export EMAIL="[email protected]"
export PASSWORD="your-password"

No token management needed! Unlike JWT-based APIs, Basic Auth doesn't require separate authentication endpoints or token refresh. Your credentials are sent with each request.

Quick links:

• Full authentication guide

• Using Basic Auth with Dispatcher

Step 2: Validate Request

Call the /validate endpoint with your complete request:

Validation Endpoint

POST /api/invoicing/validate
POST /api/email/validate
POST /api/sms/validate
POST /api/postal/validate
POST /api/esign/validate
POST /api/upload/validate

Example Validation Request

curl -X POST https://api.docs-dispatcher.io/api/invoicing/validate \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d '{
    "providerName": "qonto",
    "documentType": "INVOICE",
    "template": {
      "id": 123,
      "data": {
        "invoiceNumber": "INV-2026-001",
        "date": "2026-02-13",
        "dueDate": "2026-03-13",
        "customer": {
          "name": "Acme Corp",
          "email": "[email protected]"
        },
        "items": [
          {
            "description": "Web Development",
            "quantity": 10,
            "unitPrice": 150.00,
            "total": 1500.00
          }
        ],
        "total": 1800.00
      }
    }
  }'

Validation Success Response

{
  "valid": true,
  "message": "Request is valid and ready for dispatch",
  "warnings": []
}

Validation Error Response

{
  "valid": false,
  "errors": [
    {
      "field": "template.data.customer.email",
      "message": "Invalid email format",
      "value": "invalid-email",
      "expected": "Valid email address"
    },
    {
      "field": "template.data.total",
      "message": "Total (1800.00) does not match items sum (1500.00)",
      "expected": 1500.00,
      "actual": 1800.00
    }
  ]
}

Validation with Warnings

{
  "valid": true,
  "message": "Request is valid with warnings",
  "warnings": [
    {
      "field": "template.data.dueDate",
      "message": "Due date is only 7 days from invoice date (typically 30+ days)",
      "level": "warning",
      "value": "2026-02-20"
    },
    {
      "field": "template.data.items",
      "message": "Large number of line items (45) may affect rendering performance",
      "level": "info",
      "value": 45
    }
  ]
}

Step 3: Handle Validation Errors

When validation fails, fix the errors and re-validate.

Error Handling Pattern

async function validateAndFixErrors(requestData) {
  let attempts = 0;
  const maxAttempts = 3;

  while (attempts < maxAttempts) {
    const validation = await validateRequest(requestData);

    if (validation.valid) {
      console.log('Validation passed!');
      if (validation.warnings && validation.warnings.length > 0) {
        console.warn('Warnings:', validation.warnings);
      }
      return requestData;
    }

    console.error(`Validation failed (attempt ${attempts + 1}):`, validation.errors);

    // Fix errors programmatically
    requestData = fixValidationErrors(requestData, validation.errors);

    attempts++;
  }

  throw new Error('Could not fix validation errors after ' + maxAttempts + ' attempts');
}

function fixValidationErrors(requestData, errors) {
  errors.forEach(error => {
    switch (error.field) {
      case 'template.data.total':
        // Recalculate total
        const items = requestData.template.data.items;
        const subtotal = items.reduce((sum, item) => sum + item.total, 0);
        requestData.template.data.total = subtotal * 1.20; // Add 20% tax
        break;

      case 'template.data.customer.email':
        // Fix email format
        requestData.template.data.customer.email =
          requestData.template.data.customer.email.toLowerCase().trim();
        break;

      case 'template.data.dueDate':
        // Ensure due date is after invoice date
        const invoiceDate = new Date(requestData.template.data.date);
        const dueDate = new Date(invoiceDate);
        dueDate.setDate(dueDate.getDate() + 30);
        requestData.template.data.dueDate = dueDate.toISOString().split('T')[0];
        break;
    }
  });

  return requestData;
}

Step 4: Send Dispatch

Once validation passes, send the real dispatch by changing the endpoint from /validate to the actual service endpoint.

From Validation to Dispatch

Validation (Step 2):

POST /api/invoicing/validate

Real Dispatch (Step 4):

POST /api/invoicing

Same request body - just change the endpoint!

Send Request

curl -X POST https://api.docs-dispatcher.io/api/invoicing \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d '{
    "providerName": "qonto",
    "documentType": "INVOICE",
    "template": {
      "id": 123,
      "data": {
        "invoiceNumber": "INV-2026-001",
        "date": "2026-02-13",
        "dueDate": "2026-03-13",
        "customer": {
          "name": "Acme Corp",
          "email": "[email protected]"
        },
        "items": [
          {
            "description": "Web Development",
            "quantity": 10,
            "unitPrice": 150.00,
            "total": 1500.00
          }
        ],
        "total": 1800.00
      }
    }
  }'

Success Response

{
  "success": true,
  "dispatchId": "disp_inv_abc123",
  "providerResponse": {
    "invoiceId": "qonto_inv_789",
    "status": "sent",
    "url": "https://qonto.com/invoices/789"
  },
  "generatedDocument": {
    "url": "https://storage.docs-dispatcher.io/invoices/INV-2026-001.pdf"
  },
  "executionTime": 2.3
}

Complete Implementation Examples

curl (Complete Validate-Then-Send Flow)

#!/bin/bash
set -e

# Configuration
TEMPLATER_API="https://api.docs-dispatcher.io"
DISPATCHER_API="https://api.docs-dispatcher.io"

# Step 1: Authenticate
echo "=== Step 1: Authentication ==="
AUTH_RESPONSE=$(curl -s -X POST $TEMPLATER_API/auth \
  -H "Content-Type: application/json" \
  -d '{
    "email": "[email protected]",
    "password": "your-secure-password"
  }')

JWT_TOKEN=$(echo $AUTH_RESPONSE | jq -r '.token')
echo "✓ JWT Token obtained"

# Step 2: Prepare request
echo -e "\n=== Step 2: Prepare Request ==="
REQUEST_DATA='{
  "providerName": "qonto",
  "documentType": "INVOICE",
  "template": {
    "id": 123,
    "data": {
      "invoiceNumber": "INV-2026-001",
      "date": "2026-02-13",
      "dueDate": "2026-03-13",
      "customer": {
        "name": "Acme Corp",
        "email": "[email protected]"
      },
      "items": [
        {
          "description": "Web Development",
          "quantity": 10,
          "unitPrice": 150.00,
          "total": 1500.00
        }
      ],
      "subtotal": 1500.00,
      "taxRate": 0.20,
      "taxAmount": 300.00,
      "total": 1800.00
    }
  }
}'

# Step 3: Validate
echo -e "\n=== Step 3: Validation ==="
VALIDATION_RESPONSE=$(curl -s -X POST $DISPATCHER_API/api/invoicing/validate \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d "$REQUEST_DATA")

VALID=$(echo $VALIDATION_RESPONSE | jq -r '.valid')

if [ "$VALID" = "true" ]; then
  echo "✓ Validation passed"

  # Check for warnings
  WARNINGS=$(echo $VALIDATION_RESPONSE | jq -r '.warnings // [] | length')
  if [ "$WARNINGS" -gt 0 ]; then
    echo "⚠ Warnings:"
    echo $VALIDATION_RESPONSE | jq -r '.warnings[] | "  - \(.field): \(.message)"'
  fi
else
  echo "✗ Validation failed:"
  echo $VALIDATION_RESPONSE | jq -r '.errors[] | "  - \(.field): \(.message)"'
  exit 1
fi

# Step 4: Send dispatch
echo -e "\n=== Step 4: Dispatch ==="
DISPATCH_RESPONSE=$(curl -s -X POST $DISPATCHER_API/api/invoicing \
  -u "$EMAIL:$PASSWORD" \
  -H "Content-Type: application/json" \
  -d "$REQUEST_DATA")

SUCCESS=$(echo $DISPATCH_RESPONSE | jq -r '.success')

if [ "$SUCCESS" = "true" ]; then
  echo "✓ Dispatch successful"
  echo "  Dispatch ID: $(echo $DISPATCH_RESPONSE | jq -r '.dispatchId')"
  echo "  Invoice ID: $(echo $DISPATCH_RESPONSE | jq -r '.providerResponse.invoiceId')"
  echo "  Invoice URL: $(echo $DISPATCH_RESPONSE | jq -r '.providerResponse.url')"
  echo "  Execution Time: $(echo $DISPATCH_RESPONSE | jq -r '.executionTime')s"
else
  echo "✗ Dispatch failed:"
  echo $DISPATCH_RESPONSE | jq
  exit 1
fi

echo -e "\n=== Complete! ==="

Node.js (Complete Validate-Then-Send Flow)

const fetch = require('node-fetch');

class ValidateThenSendDispatcher {
  constructor(config) {
    this.config = config;
    this.jwtToken = null;
  }

  // Step 1: Authentication
  async authenticate() {
    console.log('=== Step 1: Authentication ===');

    const response = await fetch(`${this.config.templaterApiUrl}/auth`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        email: this.config.email,
        password: this.config.password
      })
    });

    if (!response.ok) {
      throw new Error(`Authentication failed: ${response.statusText}`);
    }

    const data = await response.json();
    this.jwtToken = data.token;
    console.log('✓ JWT Token obtained\n');

    return this.jwtToken;
  }

  // Step 2: Validate request
  async validate(requestData, service = 'invoicing') {
    console.log('=== Step 2: Validation ===');

    const response = await fetch(
      `${this.config.dispatcherApiUrl}/api/${service}/validate`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.jwtToken}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestData)
      }
    );

    const validation = await response.json();

    if (!validation.valid) {
      console.error('✗ Validation failed:');
      validation.errors.forEach(err => {
        console.error(`  - ${err.field}: ${err.message}`);
      });
      throw new ValidationError('Validation failed', validation.errors);
    }

    console.log('✓ Validation passed');

    if (validation.warnings && validation.warnings.length > 0) {
      console.warn('⚠ Warnings:');
      validation.warnings.forEach(warn => {
        console.warn(`  - ${warn.field}: ${warn.message}`);
      });
    }

    console.log('');
    return validation;
  }

  // Step 3: Send dispatch
  async dispatch(requestData, service = 'invoicing') {
    console.log('=== Step 3: Dispatch ===');

    const response = await fetch(
      `${this.config.dispatcherApiUrl}/api/${service}`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.jwtToken}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(requestData)
      }
    );

    const result = await response.json();

    if (!result.success) {
      console.error('✗ Dispatch failed:', result.message);
      throw new DispatchError(result.message, result);
    }

    console.log('✓ Dispatch successful');
    console.log(`  Dispatch ID: ${result.dispatchId}`);
    console.log(`  Execution Time: ${result.executionTime}s\n`);

    return result;
  }

  // Complete workflow
  async validateThenSend(requestData, service = 'invoicing') {
    try {
      // Step 1: Authenticate if needed
      if (!this.jwtToken) {
        await this.authenticate();
      }

      // Step 2: Validate
      await this.validate(requestData, service);

      // Step 3: Dispatch
      const result = await this.dispatch(requestData, service);

      console.log('=== Complete! ===');
      return result;

    } catch (error) {
      console.error('Error:', error.message);
      throw error;
    }
  }
}

// Custom error classes
class ValidationError extends Error {
  constructor(message, errors) {
    super(message);
    this.name = 'ValidationError';
    this.errors = errors;
  }
}

class DispatchError extends Error {
  constructor(message, details) {
    super(message);
    this.name = 'DispatchError';
    this.details = details;
  }
}

// Usage example
async function main() {
  const dispatcher = new ValidateThenSendDispatcher({
    templaterApiUrl: 'https://api.docs-dispatcher.io',
    dispatcherApiUrl: 'https://api.docs-dispatcher.io',
    email: '[email protected]',
    password: 'your-secure-password'
  });

  const invoiceData = {
    providerName: 'qonto',
    documentType: 'INVOICE',
    template: {
      id: 123,
      data: {
        invoiceNumber: 'INV-2026-001',
        date: '2026-02-13',
        dueDate: '2026-03-13',
        customer: {
          name: 'Acme Corp',
          email: '[email protected]'
        },
        items: [
          {
            description: 'Web Development',
            quantity: 10,
            unitPrice: 150.00,
            total: 1500.00
          }
        ],
        total: 1800.00
      }
    }
  };

  try {
    const result = await dispatcher.validateThenSend(invoiceData, 'invoicing');
    console.log('Invoice sent successfully!');
    console.log('Invoice URL:', result.providerResponse.url);
  } catch (error) {
    console.error('Failed:', error.message);
    process.exit(1);
  }
}

main();

PHP (Complete Validate-Then-Send Flow)

<?php
require 'vendor/autoload.php';

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;

class ValidateThenSendDispatcher {
    private $client;
    private $config;
    private $jwtToken;

    public function __construct($config) {
        $this->client = new Client();
        $this->config = $config;
    }

    // Step 1: Authentication
    public function authenticate() {
        echo "=== Step 1: Authentication ===\n";

        try {
            $response = $this->client->post($this->config['templaterApiUrl'] . '/auth', [
                'json' => [
                    'email' => $this->config['email'],
                    'password' => $this->config['password']
                ]
            ]);

            $data = json_decode($response->getBody(), true);
            $this->jwtToken = $data['token'];
            echo "✓ JWT Token obtained\n\n";

            return $this->jwtToken;

        } catch (RequestException $e) {
            throw new Exception("Authentication failed: " . $e->getMessage());
        }
    }

    // Step 2: Validate request
    public function validate($requestData, $service = 'invoicing') {
        echo "=== Step 2: Validation ===\n";

        try {
            $response = $this->client->post(
                $this->config['dispatcherApiUrl'] . "/api/{$service}/validate",
                [
                    'headers' => [
                        'Authorization' => 'Bearer ' . $this->jwtToken,
                        'Content-Type' => 'application/json'
                    ],
                    'json' => $requestData
                ]
            );

            $validation = json_decode($response->getBody(), true);

            if (!$validation['valid']) {
                echo "✗ Validation failed:\n";
                foreach ($validation['errors'] as $error) {
                    echo "  - {$error['field']}: {$error['message']}\n";
                }
                throw new ValidationException('Validation failed', $validation['errors']);
            }

            echo "✓ Validation passed\n";

            if (isset($validation['warnings']) && count($validation['warnings']) > 0) {
                echo "⚠ Warnings:\n";
                foreach ($validation['warnings'] as $warning) {
                    echo "  - {$warning['field']}: {$warning['message']}\n";
                }
            }

            echo "\n";
            return $validation;

        } catch (RequestException $e) {
            throw new Exception("Validation request failed: " . $e->getMessage());
        }
    }

    // Step 3: Send dispatch
    public function dispatch($requestData, $service = 'invoicing') {
        echo "=== Step 3: Dispatch ===\n";

        try {
            $response = $this->client->post(
                $this->config['dispatcherApiUrl'] . "/api/{$service}",
                [
                    'headers' => [
                        'Authorization' => 'Bearer ' . $this->jwtToken,
                        'Content-Type' => 'application/json'
                    ],
                    'json' => $requestData
                ]
            );

            $result = json_decode($response->getBody(), true);

            if (!$result['success']) {
                throw new Exception("Dispatch failed: {$result['message']}");
            }

            echo "✓ Dispatch successful\n";
            echo "  Dispatch ID: {$result['dispatchId']}\n";
            echo "  Execution Time: {$result['executionTime']}s\n\n";

            return $result;

        } catch (RequestException $e) {
            throw new Exception("Dispatch failed: " . $e->getMessage());
        }
    }

    // Complete workflow
    public function validateThenSend($requestData, $service = 'invoicing') {
        try {
            // Step 1: Authenticate if needed
            if (!$this->jwtToken) {
                $this->authenticate();
            }

            // Step 2: Validate
            $this->validate($requestData, $service);

            // Step 3: Dispatch
            $result = $this->dispatch($requestData, $service);

            echo "=== Complete! ===\n";
            return $result;

        } catch (Exception $e) {
            echo "Error: " . $e->getMessage() . "\n";
            throw $e;
        }
    }
}

class ValidationException extends Exception {
    private $errors;

    public function __construct($message, $errors) {
        parent::__construct($message);
        $this->errors = $errors;
    }

    public function getErrors() {
        return $this->errors;
    }
}

// Usage
$dispatcher = new ValidateThenSendDispatcher([
    'templaterApiUrl' => 'https://api.docs-dispatcher.io',
    'dispatcherApiUrl' => 'https://api.docs-dispatcher.io',
    'email' => '[email protected]',
    'password' => 'your-secure-password'
]);

$invoiceData = [
    'providerName' => 'qonto',
    'documentType' => 'INVOICE',
    'template' => [
        'id' => 123,
        'data' => [
            'invoiceNumber' => 'INV-2026-001',
            'date' => '2026-02-13',
            'dueDate' => '2026-03-13',
            'customer' => [
                'name' => 'Acme Corp',
                'email' => '[email protected]'
            ],
            'items' => [
                [
                    'description' => 'Web Development',
                    'quantity' => 10,
                    'unitPrice' => 150.00,
                    'total' => 1500.00
                ]
            ],
            'total' => 1800.00
        ]
    ]
];

try {
    $result = $dispatcher->validateThenSend($invoiceData, 'invoicing');
    echo "Invoice sent successfully!\n";
    echo "Invoice URL: {$result['providerResponse']['url']}\n";
} catch (Exception $e) {
    echo "Failed: " . $e->getMessage() . "\n";
    exit(1);
}

Java (Complete Validate-Then-Send Flow)

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import java.util.*;

public class ValidateThenSendDispatcher {
    private final HttpClient client;
    private final Gson gson;
    private final Map<String, String> config;
    private String jwtToken;

    public ValidateThenSendDispatcher(Map<String, String> config) {
        this.client = HttpClient.newHttpClient();
        this.gson = new Gson();
        this.config = config;
    }

    // Step 1: Authentication
    public String authenticate() throws Exception {
        System.out.println("=== Step 1: Authentication ===");

        Map<String, String> authData = new HashMap<>();
        authData.put("email", config.get("email"));
        authData.put("password", config.get("password"));

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(config.get("templaterApiUrl") + "/auth"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(authData)))
            .build();

        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        if (response.statusCode() != 200) {
            throw new Exception("Authentication failed: " + response.body());
        }

        JsonObject data = gson.fromJson(response.body(), JsonObject.class);
        this.jwtToken = data.get("token").getAsString();
        System.out.println("✓ JWT Token obtained\n");

        return this.jwtToken;
    }

    // Step 2: Validate request
    public JsonObject validate(Map<String, Object> requestData, String service) throws Exception {
        System.out.println("=== Step 2: Validation ===");

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(config.get("dispatcherApiUrl") + "/api/" + service + "/validate"))
            .header("Authorization", "Bearer " + this.jwtToken)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(requestData)))
            .build();

        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        JsonObject validation = gson.fromJson(response.body(), JsonObject.class);

        if (!validation.get("valid").getAsBoolean()) {
            System.err.println("✗ Validation failed:");
            validation.getAsJsonArray("errors").forEach(error -> {
                JsonObject err = error.getAsJsonObject();
                System.err.println("  - " + err.get("field").getAsString() +
                    ": " + err.get("message").getAsString());
            });
            throw new ValidationException("Validation failed");
        }

        System.out.println("✓ Validation passed\n");
        return validation;
    }

    // Step 3: Send dispatch
    public JsonObject dispatch(Map<String, Object> requestData, String service) throws Exception {
        System.out.println("=== Step 3: Dispatch ===");

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(config.get("dispatcherApiUrl") + "/api/" + service))
            .header("Authorization", "Bearer " + this.jwtToken)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(gson.toJson(requestData)))
            .build();

        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        JsonObject result = gson.fromJson(response.body(), JsonObject.class);

        if (!result.get("success").getAsBoolean()) {
            throw new Exception("Dispatch failed: " + result.get("message").getAsString());
        }

        System.out.println("✓ Dispatch successful");
        System.out.println("  Dispatch ID: " + result.get("dispatchId").getAsString());
        System.out.println("  Execution Time: " + result.get("executionTime").getAsDouble() + "s\n");

        return result;
    }

    // Complete workflow
    public JsonObject validateThenSend(Map<String, Object> requestData, String service) throws Exception {
        try {
            // Step 1: Authenticate if needed
            if (this.jwtToken == null) {
                authenticate();
            }

            // Step 2: Validate
            validate(requestData, service);

            // Step 3: Dispatch
            JsonObject result = dispatch(requestData, service);

            System.out.println("=== Complete! ===");
            return result;

        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
            throw e;
        }
    }

    public static void main(String[] args) {
        Map<String, String> config = new HashMap<>();
        config.put("templaterApiUrl", "https://api.docs-dispatcher.io");
        config.put("dispatcherApiUrl", "https://api.docs-dispatcher.io");
        config.put("email", "[email protected]");
        config.put("password", "your-secure-password");

        ValidateThenSendDispatcher dispatcher = new ValidateThenSendDispatcher(config);

        Map<String, Object> invoiceData = new HashMap<>();
        invoiceData.put("providerName", "qonto");
        invoiceData.put("documentType", "INVOICE");
        // ... add template data

        try {
            JsonObject result = dispatcher.validateThenSend(invoiceData, "invoicing");
            System.out.println("Invoice sent successfully!");
        } catch (Exception e) {
            System.err.println("Failed: " + e.getMessage());
            System.exit(1);
        }
    }
}

class ValidationException extends Exception {
    public ValidationException(String message) {
        super(message);
    }
}

Best Practices

1. Always Validate in Development

// Development mode
if (process.env.NODE_ENV === 'development') {
  await validate(requestData);
}
await dispatch(requestData);

2. Optional Validation in Production

// Production mode (optional but recommended)
if (config.validateBeforeSend) {
  await validate(requestData);
}
await dispatch(requestData);

3. Cache Validation Results

const validationCache = new Map();

async function validateWithCache(requestData) {
  const cacheKey = JSON.stringify(requestData);

  if (validationCache.has(cacheKey)) {
    console.log('Using cached validation result');
    return validationCache.get(cacheKey);
  }

  const validation = await validate(requestData);
  validationCache.set(cacheKey, validation);

  return validation;
}

4. User Feedback Integration

// Show validation errors to users before submission
async function handleFormSubmit(formData) {
  const requestData = buildRequestFromForm(formData);

  // Validate first
  const validation = await validate(requestData);

  if (!validation.valid) {
    // Show errors to user
    displayValidationErrors(validation.errors);
    return;
  }

  // Show warnings to user (optional)
  if (validation.warnings && validation.warnings.length > 0) {
    const userConfirmed = await confirmWithWarnings(validation.warnings);
    if (!userConfirmed) {
      return;
    }
  }

  // Proceed with dispatch
  const result = await dispatch(requestData);
  displaySuccess(result);
}

5. CI/CD Integration

// Test validation in CI/CD pipeline
describe('Invoice Request Validation', () => {
  it('should validate correct invoice data', async () => {
    const invoiceData = buildTestInvoice();
    const validation = await validate(invoiceData);
    expect(validation.valid).toBe(true);
  });

  it('should reject invalid email', async () => {
    const invoiceData = buildTestInvoice();
    invoiceData.template.data.customer.email = 'invalid';

    const validation = await validate(invoiceData);
    expect(validation.valid).toBe(false);
    expect(validation.errors).toContainObject({
      field: 'template.data.customer.email'
    });
  });
});

When to Skip Validation

You can skip validation in these scenarios:

1. Known good data - Request structure proven correct

2. Performance critical - Every millisecond counts

3. Trusted input - Data from validated internal systems

4. Batch processing - Pre-validated data sets

Skipping validation increases risk of failed dispatches, wasted credits, and poor user experience. Only skip when absolutely necessary.

Troubleshooting

Issue: "Validation passes but dispatch fails"

Cause: Validation doesn't check external provider state

Solution:

• Validation checks request structure only

• Provider may reject due to business rules (duplicate invoice, etc.)

• Implement proper error handling for dispatch step

Issue: "Validation too slow"

Cause: Network latency or large request

Solution:

• Cache validation results for identical requests

• Validate critical fields only in some cases

• Use async validation with loading indicators

Next Steps

Related Recipes

• Invoice - Complete invoice workflow

• Async Flow - Asynchronous dispatch patterns

• Troubleshooting - Debug common issues

Core Concepts

• Validation - Validation fundamentals

• Error Handling - Handle errors gracefully

Summary

You've learned:

• ✅ Why validation before dispatch is critical

• ✅ How to validate requests without side effects

• ✅ Handling validation errors and warnings

• ✅ Complete validate-then-send implementations in 4 languages

• ✅ Best practices for production use

• ✅ When to skip validation

Validation is your safety net - use it to catch errors early, save credits, and deliver better user experiences!