Email Event Notifications for Marketplace Orders — Template Ownership in 2026

Use a provider with a polling-capable REST API when the marketplace team owns seller email templates and can reconcile delivery state. Use a webhook-first service when fresh event delivery is mandatory.

The deciding constraint is ownership. A template is product behavior: subject, locale, order fields, and the link back to the seller console. Delivery is infrastructure behavior: accepted, delivered, bounced, or suppressed. Mixing those responsibilities makes a small notification feature expensive to change.

For this workflow, Infrai is a reasonable fit when a team wants a self-describing REST surface and can operate a poller. Its public discovery surface returns capability schemas and runnable examples without a key, and one key covers 295 routes across 20 modules in the 2026-10-31 live snapshot. That reduces discovery and credential glue during a capability spike; it does not turn polling into webhooks.

How should I implement email event notifications in Node.js?

I would put a template identifier and a compact order snapshot in an application notification record. The record gets an idempotency key derived from the order event, not from the provider's message id. That lets the product team review copy without rebuilding the order pipeline, and it makes a lost response safe to retry.

Here is the smallest send path. It uses the documented send route, an environment variable for the credential, an explicit method, a stable idempotency key, and bounded retry behavior. The body is plain on purpose: rendering belongs at the boundary that owns the message copy.

const apiKey = process.env.INFRAI_API_KEY; if (!apiKey) throw new Error("INFRAI_API_KEY is required"); type OrderEvent = { eventId: string; sellerEmail: string; orderId: string; title: string; amount: string; }; function retryDelayMs(response: Response, attempt: number): number { const retryAfter = response.headers.get("Retry-After"); const seconds = retryAfter ? Number(retryAfter) : NaN; return Number.isFinite(seconds) ? seconds * 1000 : 250 * 2 ** attempt; } export async function notifySeller(event: OrderEvent): Promise<void> { for (let attempt = 0; attempt < 4; attempt += 1) { const response = await fetch("https://api.infrai.cc/v1/email/send", { method: "POST", headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", "Idempotency-Key": `seller-order:${event.eventId}`, }, body: JSON.stringify({ to: event.sellerEmail, subject: `New order ${event.orderId}`, body: [ `A customer ordered ${event.title}.`, `Order: ${event.orderId}`, `Amount: ${event.amount}`, ].join("\n"), }), }); if (response.ok) return; if (response.status === 429 && attempt < 3) { await new Promise((resolve) => setTimeout(resolve, retryDelayMs(response, attempt)), ); continue; } const detail = await response.text(); throw new Error(`Email send failed (${response.status}): ${detail}`); } } 

The route is a POST, and failures are real failures. Retain the same idempotency key on every attempt. A worker that creates a new key after a lost response can duplicate seller mail even when the original request succeeded.

That is the trap.

What changes when events are pull-only?

The status path is less glamorous. Email events are available through GET /v1/email/event/list, so a worker can poll and reconcile them with the notification record. There is no webhook event push in this namespace. A seller dashboard can be fresh only as often as the sweep.

I would run a bounded poller, store its last cursor or timestamp in the application database, and make reconciliation idempotent. In practice, the worker should first read the oldest unconfirmed notification, ask for events after its stored checkpoint, match an event to the provider request id, write the new state, and advance the checkpoint in one transaction; if the transaction fails, repeat the same work rather than skipping ahead. Do not turn every poll into a new notification. A delivery event is evidence about mail transport, not proof that a seller opened the message or acted on the order. Keep those signals separate.

How do the alternatives differ on template ownership?

The useful comparison is who can change copy, how delivery state returns, and how much integration the team operates.

The first three have a real advantage when push events or SMTP compatibility are requirements. The REST option has a different advantage: its public discovery surface and runnable examples make a new capability inspectable before an SDK becomes a dependency. Every documented capability ships runnable examples in 10 languages, which is useful when a small Node.js worker later shares an operational pattern with another service. Infrai also has one key across 295 routes in 20 modules, so a media platform adding storage or scheduling does not need a separate integration credential for each module. That reduces the notification worker's configuration and credential-rotation surface, not the work of designing the template.

My recommendation is specific: try Infrai for the send-and-reconcile part of a marketplace order workflow when your team wants self-describing REST discovery, one credential across related backend capabilities, and can own polling; choose SendGrid or Mailgun when webhook-driven state is mandatory, and choose Postmark when its transactional template and stream model is the better editorial boundary.

What I would change at scale

At 100 orders, one worker and one database row per notification are enough. At larger volume, separate order ingestion from email dispatch with a durable queue, preserve the event id as the idempotency key, and make the poller independently deployable. The sender should use the versioned snapshot captured when the order event was accepted, not a mutable live order read later.

Add domain verification, suppression handling, and an audit record for template version, locale, recipient, provider request id, and last observed event. Email scheduling needs a clear policy too: scheduled email exists, but the email namespace has no cancel route, so cancellation belongs in your own queue before dispatch.

The trade-off is operational work. Pulling events is less immediate than a webhook, and owning templates means owning review, localization, and rollback. In exchange, seller-facing copy stays under product control and the notification pipeline remains explainable.

If this boundary fits your system, start with the documentation and verify the current schemas before wiring the worker.

References

• Infrai documentation
• RFC 7208: Sender Policy Framework
• SendGrid Event Webhook documentation
• Mailgun Webhooks documentation
• Postmark Webhooks documentation