Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    AI Agent Webhook Reliability Engineer

    1

    Design reliable, secure webhook architectures with retries, idempotency, and SSRF protection for AI agents and SaaS.

    $39.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    AI Agent Webhook Reliability Engineer

    AI Agent Webhook Reliability Engineer

    Example session with this skill installed

    Design a reliable webhook system for a Stripe-like payment service using Node.js and Redis. I need to handle at-least-once delivery and prevent duplicate payouts.

    • Read your context and instructions
    • Compiled the ai agent webhook

    I have designed a high-reliability webhook delivery architecture tailored for a payment service using a Node.js worker tier and Redis-backed task queuing.

    Webhook Reliability Architecture

    Event Envelope and Identity

    All events follow a versioned schema to ensure consumer compatibility.

    FieldTypeDescription
    idUUIDUnique event identifier (Event ID)
    typeStringe.g., payment.succeeded
    created_atISO8601Original event timestamp
    idempotency_keyStringKey for safe retries of side effects
    dataObjectThe actual payment payload

    Delivery Retry Policy

    The system distinguishes between transient and permanent failures to optimize queue throughput.

    Response CodeActionBackoff Strategy
    200, 201, 204SuccessMark as delivered
    429, 502, 503, 504RetryExponential backoff (initial 30s, max 24h)
    400, 401, 404DLQMove to Dead Letter Queue after 1 attempt
    Timeout (>10s)RetryExponential backoff with jitter

    Implementation: Signature Verification (Node.js)

    const crypto = require('crypto');
    
    function verifySignature(payload, signature, secret) {
      // Use raw request body bytes for verification
      const hmac = crypto.createHmac('sha256', secret);
      const digest = Buffer.from('v1=' + hmac.update(payload).digest('hex'), 'utf8');
      const sigBuffer = Buffer.from(signature, 'utf8');
    
      if (sigBuffer.length !== digest.length) return false;
      return crypto.timingSafeEqual(digest, sigBuffer);
    }
    

    Idempotency Strategy

    Consumers must implement a "check-and-set" pattern. Before processing a payout, the consumer checks if the event_id exists in their processed_events table. The payout execution and the event ID recording must happen within a single database transaction.

    Next steps

    1. Implement the Transactional Outbox pattern in your main database to ensure events are captured during payment state changes.
    2. Configure Redis with persistence (AOF/RDB) to prevent event loss during broker restarts.
    3. Set up Prometheus metrics for webhook_delivery_failure_rate and queue_age_seconds.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Distributed systems fail most often at the integration points. When your AI agents or SaaS platforms rely on webhooks, you face silent failures, duplicate side effects, and security vulnerabilities like SSRF. This skill provides the architectural blueprints and operational logic needed to build production-ready event delivery systems that don't lose data.

    What it does

    • Reliability engineering designs systems for at-least-once delivery using durable queues and transactional outbox patterns.
    • Security hardening defines HMAC signature verification flows and SSRF protection to prevent unauthorized event injection.
    • Failure recovery establishes exponential backoff policies with jitter and dead-letter queue (DLQ) management.
    • Data integrity provides idempotency strategies to handle duplicate deliveries without breaking business logic.
    • Traffic control defines per-endpoint rate limits and concurrency management to avoid crashing downstream consumers.

    How it works

    1. Discovery phase identifies your producers, event volumes, and latency targets through a structured checklist.
    2. Architecture design generates a detailed plan covering event envelopes, worker logic, and signature schemes.
    3. Policy definition creates a retry matrix that distinguishes between transient 5xx errors and permanent 4xx failures.
    4. Implementation mapping produces API contracts, sample payloads, and a phased roadmap for deployment.

    Frameworks & tools

    The skill adapts to your existing stack including message brokers like RabbitMQ, Kafka, or AWS SQS, and databases like PostgreSQL (for the outbox pattern) or Redis.

    Why this beats prompting it yourself

    Generic prompts often overlook the complexities of distributed systems like event ordering, idempotency keys, and SSRF prevention. This skill enforces strict engineering principles, ensuring you don't miss critical edge cases like replay windows or signature canonicalization.

    Use cases

    • Building a webhook provider for a multi-tenant SaaS application.
    • Ensuring AI agent tool calls reliably trigger external workflows.
    • Designing a retry and replay system for failed payment notifications.
    • Implementing secure event signing between microservices.

    Known limitations

    Does not perform actual infrastructure provisioning or live endpoint configuration. The output is architectural guidance and implementation-ready design patterns rather than a deployed service.

    Architectural design only. Does not execute code, provision cloud resources, or configure live API endpoints. Output is implementation-ready guidance.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 4 days ago

    Permissions

    Network Access
    Listed4 days ago

    What's inside

    Frequently Asked Questions

    This skill provides the architectural blueprints, retry logic policies, and security patterns needed to build a resilient event delivery system, solving issues like duplicate data, silent failures, and SSRF vulnerabilities.

    The skill is framework-agnostic and provides design patterns compatible with any AI agent or SaaS stack using message brokers like Kafka, RabbitMQ, or AWS SQS.

    You receive comprehensive architectural designs, API contracts, idempotency strategies, and a phased implementation roadmap tailored to your specific event volume and latency needs.

    While it provides implementation-ready logic and API contracts, it does not perform live infrastructure provisioning or code deployment; you will need to apply the designs to your specific environment.

    Unlike generic prompts, this skill enforces strict distributed systems principles like transactional outboxes and signature canonicalization to ensure you don't miss critical edge cases.

    New in APIs & Backend