Building Self-Healing Payment Webhook Queues on Cloudflare Edge Workers

The Fragile Nature of Payment Webhooks

In high-conversion digital architectures, webhooks are the lifeblood of transactional software. When a customer completes a checkout (e.g. subscribing to an agency portal, buying a domain, paying a deposit), their account must transition state instantly.

But webhooks are inherently fragile.

If your database undergoes a minor connection pool lockup, or if Supabase experiences a sub-second edge timeout during checkout, the webhook fails. Standard payment APIs (like Stripe) will retry, but their retries can take hours. To your customer, the site appears broken, prompting immediate client support complaints.

---

The Architectural Solution: Edge-Queued Webhooks

To guarantee 100% billing-to-portal synchronization, we engineered a custom, self-healing transactional queue hosted on Cloudflare Edge Workers.

Instead of writing webhooks that directly query the core Postgres database in a single block, we decouple the process:

---

Custom Edge Queue Implementation Code

Here is a simplified, highly robust TypeScript implementation for an Edge-queued webhook processor:

interface Env {
  SUPABASE_SERVICE_ROLE_KEY: string;
  SUPABASE_URL: string;
}
export default {
  async fetch(request: Request, env: Env): Promise {
    if (request.method !== "POST") {
      return new Response("Method Not Allowed", { status: 405 });
    }
    try {
      const payload = await request.json() as any;
      
      // 1. Instantly queue payload & return HTTP 200 to payment gateway
      // In CF Workers, you can utilize waitUntil to process async in the background
      ctx.waitUntil(processWebhookWithRetry(payload, env, 1));
      return new Response(JSON.stringify({ queued: true }), {
        status: 200,
        headers: { "Content-Type": "application/json" }
      });
    } catch (err: any) {
      return new Response(err?.message || "Error", { status: 400 });
    }
  }
};
async function processWebhookWithRetry(payload: any, env: Env, attempt: number) {
  const MAX_ATTEMPTS = 5;
  const BACKOFF_TIME = Math.pow(2, attempt) * 1000; // Exponential: 2s, 4s, 8s, 16s...
  try {
    const res = await fetch(${env.SUPABASE_URL}/rest/v1/stripe_webhook_queue, {
      method: "POST",
      headers: {
        "apikey": env.SUPABASE_SERVICE_ROLE_KEY,
        "Authorization": Bearer ${env.SUPABASE_SERVICE_ROLE_KEY},
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ payload })
    });
    if (!res.ok) throw new Error(Database transaction failed with status ${res.status});
    console.log("✅ Webhook sync transaction completed successfully.");
  } catch (err: any) {
    console.error(⚠️ Webhook Process Error (Attempt ${attempt}/${MAX_ATTEMPTS}): ${err.message});
    
    if (attempt < MAX_ATTEMPTS) {
      // Delay using Promise
      await new Promise(resolve => setTimeout(resolve, BACKOFF_TIME));
      await processWebhookWithRetry(payload, env, attempt + 1);
    } else {
      console.error("🔴 CRITICAL: Webhook transaction exhausted all retries. Raising Slack alarm!");
      // Trigger Slack hook alert
    }
  }
}

---

The Commercial Value of Resilient Tech

By building transactional layers using Edge queues, we protect our client portal operations from database locks, network jitters, and cloud downtime. For high-ticket agencies, this level of custom infrastructure represents supreme technical maturity—reassuring clients that their billing, portals, and data pipelines are fully engineered for 100% reliability.