Use Case

Never miss a Shopify order

Flash sales turn webhook volume into a denial-of-service — on your own order pipeline. Hooque queues every order event so fulfillment workers can drain at their own capacity.

The Challenge

E-commerce webhooks do not care about your worker limits — spikes happen instantly. Losing WooCommerce or BigCommerce order events has the same fulfillment impact as Shopify.

Flash sales spike webhook volume 10-100x normal.

Shopify has a short retry window — overwhelmed handlers lose orders.

Manual replay after incidents is risky and error-prone.

How Hooque Solves It

Hooque absorbs the spike. Your fulfillment stays calm.

Provider

Shopify

orders/create - orders/paid

Buffer

Hooque

Durable queue for bursts

Consume

Fulfillment

Drain at capacity

  • Handle any traffic spike: the queue grows, your workers stay stable.
  • Use Nack for transient failures and retry with backoff.
  • Ack and move on once fulfillment is complete — no manual replays.

Before & After

Keep the webhook receipt fast. Fulfillment happens on your terms.

Without Hooque

Burst traffic overwhelms inline fulfillment

// Shopify webhook verification + processing inline
import express from "express";

const app = express();
app.use(express.json());

// Public webhook endpoint: where should we host it so Shopify can always reach it?
app.post("/shopify/webhook", async (req, res) => {
  const hmac = req.get("x-shopify-hmac-sha256");
  // This auth/signature check is often forgotten in rushed handlers.
  if (!verifyShopifyHmac(req.rawBody, hmac, process.env.SHOPIFY_WEBHOOK_SECRET)) {
    return res.status(401).send("invalid signature");
  }

  try {
    // Hope we do not timeout while processing inline.
    await process_ecommerce_payload(req.body); // orders/create, orders/paid
    res.sendStatus(200);
  } catch (err) {
    // Do we need to send an alert here?
    // How do we know which payload failed and how to debug it later?
    res.sendStatus(500);
  }
});

With Hooque

Drain at capacity with Nack-based retries

// Stream ecommerce events from Hooque over SSE
const HOOQUE_URL = process.env.HOOQUE_URL; // e.g. https://app.hooque.io/queues/cons_shopify_orders
const TOKEN = process.env.HOOQUE_TOKEN;
const headers = { Authorization: `Bearer ${TOKEN}` };

// Signature verification is handled by Hooque before messages enter this stream.
const streamResp = await fetch(HOOQUE_URL + "/stream", { headers });

for await (const line of readSseLines(streamResp.body)) {
  if (!line.startsWith("data:")) continue;

  const event = JSON.parse(line.slice(5)); // { payload, meta }
  const payload = event.payload;
  const meta = event.meta;

  try {
    await process_ecommerce_payload(payload); // orders/create, orders/paid
    await fetch(meta.ackUrl, { method: "POST", headers });
  } catch (err) {
    // Failed message can be inspected in Hooque, and we receive an alert about it.
    await fetch(meta.nackUrl, {
      method: "POST",
      headers: { ...headers, "Content-Type": "application/json" },
      body: JSON.stringify({ reason: String(err) }),
    });
  }
}

Key Benefits

Fulfillment stays reliable even when volume is not.

Handle any traffic spike

Queue growth is cheap. Dropped orders are not.

Reliable order fulfillment

Process every order event exactly as your systems allow — without timeouts.

Controlled retry logic

Nack transient failures with a reason, reject invalid payloads, and keep an audit trail.

How It Works

Point Shopify at a hosted endpoint, then pull from a durable queue.

1

Create a webhook

Create a Hooque webhook for order events and copy the endpoint URL.

2

Point Shopify to Hooque

Configure Shopify to send orders/create (and related topics) to Hooque.

3

Consume from the queue

Workers pull events and Ack/Nack based on fulfillment outcomes.

FAQ

E-commerce webhooks FAQ

Common questions about Shopify retries, spikes, and safe fulfillment processing.

Yes. Bursts are accepted and queued quickly so Shopify does not time out, while your fulfillment workers drain events at their own capacity.
Yes. Enable Shopify HMAC verification so invalid requests are rejected at ingest before they reach your fulfillment pipeline.
Assume retries and duplicates. Use stable idempotency keys (Shopify order id + topic, or your own dedupe key) and only ack once the side effect is safely committed.
Events stay queued. You can nack transient failures to retry later without losing the original order events.
Yes. Drain the queue sequentially when ordering matters, or scale out consumers when throughput matters more than strict ordering.
Yes. Reject permanently invalid events with a reason so they are separated from retryable failures.

Still have questions?

Contact our support team

Start Processing Shopify Webhooks in 2 Minutes

Capture every order event, then drain at your own pace-even on Black Friday.

Start for free

No credit card required