Pulse Overview

hookVM Pulse is your complete solution for sending reliable webhooks to your customers and partners.

---

What is Pulse?

Pulse transforms complex webhook sending into a simple, reliable process. Instead of building custom infrastructure to deliver webhooks to your customers, Pulse provides everything you need out of the box.

In Simple Terms: Pulse sends webhooks for you, manages subscriptions, handles retries, and provides delivery tracking - so you can focus on your product.

---

The Problem

Without Pulse

Building a webhook delivery system is deceptively complex:

Common Challenges:

• ❌ Subscription Management: Track who wants which events
• ❌ Payload Signing: Secure webhooks with HMAC signatures
• ❌ Retry Logic: Handle failures gracefully
• ❌ Delivery Tracking: Know what was delivered when
• ❌ Customer Portal: Let customers manage subscriptions
• ❌ Scaling: More customers = more webhooks to send

With Pulse

Pulse handles all the complexity:

What Pulse Does:

• ✅ Subscription Management: API and UI for managing subscriptions
• ✅ Automatic Signing: HMAC signatures for security
• ✅ Smart Retries: Exponential backoff built-in
• ✅ Delivery Tracking: Monitor every delivery attempt
• ✅ Customer Portal: Self-service subscription management
• ✅ Idempotency: Prevent duplicate deliveries

---

How Pulse Works

1. Define Event Types

Create event types for things that happen in your application:

Event Types:
- order.created
- order.shipped
- payment.completed
- user.created
- subscription.cancelled

Features:

• Descriptive names (resource.action)
• Optional JSON schema validation
• Enable/disable event types
• Version your events

2. Manage Subscriptions

Customers subscribe to events they want to receive:

Subscription Options:

• Specific event types or all events
• Custom endpoint URL
• Retry configuration
• Enable/disable subscriptions

3. Send Events

Send events via API or SDK:

// Send event
await hookvm.events.send({
  eventType: 'order.shipped',
  data: {
    order_id: 'ord_123',
    tracking_number: 'TRK789',
    carrier: 'UPS'
  },
  idempotencyKey: 'ord_123-shipped'
});

Pulse Automatically:

• Finds matching subscriptions
• Creates deliveries
• Signs payloads
• Sends to customer endpoints
• Retries on failure
• Tracks all attempts

4. Monitor Deliveries

Track delivery status in real-time:

Monitoring Features:

• Real-time delivery status
• HTTP response codes
• Retry attempts
• Error messages
• Delivery timeline

---

Key Features

Event Type Management

Define and organize your webhook events:

// E-commerce events
order.created
order.paid
order.shipped
order.delivered
order.cancelled

// User events
user.created
user.updated
user.deleted

// Payment events
payment.completed
payment.failed
payment.refunded

Benefits:

• Clear event taxonomy
• Easy to understand
• Consistent naming
• Self-documenting

Subscription API

Programmatically manage customer subscriptions:

// Create subscription for customer
const subscription = await hookvm.subscriptions.create({
  eventTypes: ['order.shipped', 'order.delivered'],
  endpointUrl: 'https://customer.com/webhooks',
  retryCount: 5,
  retryBackoffMs: 2000
});

// Update subscription
await hookvm.subscriptions.update(subscription.id, {
  eventTypes: ['order.shipped', 'order.delivered', 'order.cancelled']
});

// Delete subscription
await hookvm.subscriptions.delete(subscription.id);

Use Cases:

• Onboard customers automatically
• Sync with your database
• Bulk subscription management
• Self-service portals

Automatic Retries

Never miss a delivery with smart retry logic:

Attempt 1: Immediate
Attempt 2: After 1 second
Attempt 3: After 2 seconds
Attempt 4: After 4 seconds
Attempt 5: After 8 seconds

Features:

• Exponential backoff
• Configurable retry count
• Retry only on 5xx errors
• Track all attempts

Idempotency

Prevent duplicate deliveries:

// Send event with idempotency key
await hookvm.events.send({
  eventType: 'payment.completed',
  data: { payment_id: 'pay_123' },
  idempotencyKey: 'pay_123-completed'
});

// Retry (network issue) - same key
await hookvm.events.send({
  eventType: 'payment.completed',
  data: { payment_id: 'pay_123' },
  idempotencyKey: 'pay_123-completed'
});
// Result: Returns same event, no duplicate delivery

Benefits:

• Safe retries
• Exactly-once delivery
• No duplicate webhooks
• Reliable integration

Delivery Tracking

Monitor every delivery attempt:

Track:

• Delivery status
• HTTP response codes
• Retry attempts
• Response times
• Error messages

---

Common Use Cases

SaaS Webhooks

Scenario: Send webhooks to customers when events occur

Implementation:

// When user signs up
await hookvm.events.send({
  eventType: 'user.created',
  data: {
    user_id: user.id,
    email: user.email,
    plan: user.plan,
    created_at: user.created_at
  }
});

// Pulse automatically delivers to all subscribers

E-commerce Platform

Scenario: Notify fulfillment partners of new orders

Implementation:

// When order is created
await hookvm.events.send({
  eventType: 'order.created',
  data: {
    order_id: order.id,
    items: order.items,
    shipping_address: order.shipping_address,
    total: order.total
  }
});

Payment Platform

Scenario: Send payment notifications to merchants

Implementation:

// When payment completes
await hookvm.events.send({
  eventType: 'payment.completed',
  data: {
    payment_id: payment.id,
    amount: payment.amount,
    currency: payment.currency,
    merchant_id: payment.merchant_id
  }
});

---

Getting Started

Quick Start (10 minutes)

1. Create Event Type

   Navigate to Pulse → Event Types → Create
   Name: order.shipped
   Description: Triggered when order is shipped

2. Create Subscription

   Navigate to Pulse → Subscriptions → Create
   Event Types: order.shipped
   Endpoint URL: https://customer.com/webhooks
   Retry Count: 3

3. Send Event

   await hookvm.events.send({
     eventType: 'order.shipped',
     data: { order_id: 'ord_123' }
   });

4. Monitor Delivery

   Navigate to Pulse → Deliveries
   Check delivery status
   View response codes

Next Steps

• Event Types - Define your events
• Subscriptions - Manage customer subscriptions
• Sending Events - Send events via API/SDK
• Deliveries - Monitor delivery status

---

Benefits

For Product Teams

✅ Ship Faster: Webhooks in hours, not weeks
✅ Focus on Features: Not infrastructure
✅ Better UX: Reliable webhook delivery
✅ Easy Integration: Simple API and SDKs

For Developers

✅ Simple API: Send events in 3 lines of code
✅ Great DX: SDKs for Node.js, Python, Go
✅ Easy Debugging: Real-time delivery tracking
✅ Reliable: Automatic retries and monitoring

For Customers

✅ Self-Service: Manage subscriptions themselves
✅ Reliable: Never miss important events
✅ Secure: HMAC signature verification
✅ Transparent: Track delivery status

For Businesses

✅ Faster GTM: Launch webhook features quickly
✅ Lower Costs: No infrastructure to build
✅ Higher Quality: Enterprise-grade reliability
✅ Better Support: Customers debug themselves

---

Architecture

How Pulse Delivers Webhooks

Data Flow

1. Send Event: Your app sends event to Pulse API
2. Find Subscriptions: Pulse finds matching subscriptions
3. Queue Deliveries: Create delivery for each subscription
4. Sign Payload: Add HMAC signature
5. Deliver: Send to customer endpoint
6. Retry: Automatic retries on failure
7. Track: Log all attempts and responses

---

Comparison

Pulse vs Building Your Own

Feature	Pulse	Build Your Own
Setup Time	10 minutes	Weeks/months
Subscription Management	Built-in API	Build from scratch
Retry Logic	Automatic	Implement yourself
Delivery Tracking	Real-time UI	Build dashboards
Idempotency	Built-in	Implement yourself
Customer Portal	Included	Build separate app
Scaling	Automatic	Provision infrastructure
Maintenance	Zero	Ongoing
Cost	$0-$99/month	Infrastructure + dev time

---

Ready to Start?

Pulse makes webhook sending simple, reliable, and scalable.

Create Your First Event Type →

---

Questions? Check our troubleshooting guide or contact support.