From 10 letters to 10,000: How LetterAPI scales postal infrastructure.

The scaling trap of physical infrastructure

The architectural challenge: Bridging sub-second cloud APIs with physical manufacturing

Distributed rendering clusters: Sandboxed WebAssembly and headless Chromium microVMs

Industrial print engineering: Continuous web-fed presses and optical robotic inserters

The 3-step programmatic scaling blueprint: From prototype to enterprise volume

Code walkthrough: High-volume batch dispatch with chunking and concurrency control

src/workers/batchPostalDispatcher.ts — typescript
import crypto from 'crypto';
​
interface LetterPayload {
  recipient: {
    name: string;
    address_line_1: string;
    city: string;
    postcode: string;
  };
  template: string;
  variables: Record<string, any>;
  metadata: Record<string, any>;
}
​
export class BatchPostalDispatcher {
  private apiKey: string;
  private apiUrl: string = 'https://api.letterapi.uk/v1';
  private batchChunkSize: number = 500; // Optimal payload chunking size
​
  constructor(apiKey: string) {
    this.apiKey = apiKey;
  }
​
  public async dispatchBulkLetters(letters: LetterPayload[], campaignId: string): Promise<void> {
    console.log(`Starting bulk dispatch of ${letters.length} letters for campaign ${campaignId}`);
    
    // 1. Chunk array into manageable 500-item slices
    const chunks: LetterPayload[][] = [];
    for (let i = 0; i < letters.length; i += this.batchChunkSize) {
      chunks.push(letters.slice(i, i + this.batchChunkSize));
    }
​
    // 2. Process chunks with controlled concurrency (e.g. 3 concurrent chunk uploads)
    const concurrencyLimit = 3;
    for (let i = 0; i < chunks.length; i += concurrencyLimit) {
      const batchPromiseGroup = chunks.slice(i, i + concurrencyLimit).map((chunk, index) => {
        const chunkIndex = i + index;
        const idempotencyKey = `batch_${campaignId}_chunk_${chunkIndex}`;
        return this.sendChunkWithRetry(chunk, idempotencyKey);
      });
​
      await Promise.all(batchPromiseGroup);
    }
​
    console.log(`Successfully enqueued all ${letters.length} letters into production pipeline.`);
  }
​
  private async sendChunkWithRetry(chunk: LetterPayload[], idempotencyKey: string, attempt: number = 1): Promise<any> {
    try {
      const response = await fetch(`${this.apiUrl}/batches`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json',
          'Idempotency-Key': idempotencyKey
        },
        body: JSON.stringify({
          letters: chunk,
          postage: 'first_class'
        })
      });
​
      if (!response.ok) {
        const err = await response.json();
        throw new Error(`Batch API error [${response.status}]: ${err.message}`);
      }
​
      return await response.json();
    } catch (error) {
      if (attempt < 4) {
        const delayMs = Math.pow(2, attempt) * 1000;
        console.warn(`Retry attempt ${attempt} for chunk ${idempotencyKey} after ${delayMs}ms`);
        await new Promise(res => setTimeout(res, delayMs));
        return this.sendChunkWithRetry(chunk, idempotencyKey, attempt + 1);
      }
      throw error;
    }
  }
}

Multi-site facility routing and active-active geographic load balancing

Royal Mail wholesale line-haul integration and bypassing high street bottlenecks

Elastic economics: Eliminating minimum volume penalties and setup fees

Handling webhook backpressure and event storming during 100,000-letter dispatches

Database deadlocks and idempotency keys: Engineering bulletproof retry semantics

Dynamic address deduplication and household suppression algorithms

The architectural transformation: From fragile printrooms to sovereign cloud mail infrastructure

Scale your physical postal infrastructure with LetterAPI today