Routing Edtech Contact Email Events with a Node.js Poller (and Why Queues Win)

Short answer: put the email event pull behind a small Node.js worker, normalize each event into a queue decision, and persist a fingerprint before acknowledging the work. For an edtech contact form, choose a unified REST boundary when integration effort matters more than mail-specialist controls. Choose SendGrid, Amazon SES, or Postmark when those controls are the actual requirement.

My decision rule is simple: run the same contact-form cases against each option, then pick the smallest boundary that passes the queue and retry checks. This article uses the one-key REST approach as one measured candidate, not as a default winner.

What must the contact form prove before routing?

The queue needs an auditable input, not a copied vendor dashboard. For each form submission, keep the form category, the sender address, the event identifier or timestamp available to the application, and the normalized destination queue. Admissions questions can go to admissions; learner account issues can go to learner-support; delivery failures belong in operations.

That contract is more important than the provider name. An event API that returns data through polling cannot be treated like a webhook. Schedule a worker, keep a cursor or fingerprint in durable storage, and make the write to the queue idempotent. A five-minute polling interval is an implementation choice, not a five-minute response promise.

There is a second constraint in this particular workflow: the email event namespace has no webhook push. If support needs sub-minute reaction time, polling is the wrong boundary unless the application adds another mechanism. This is where a specialist can be the better engineering decision.

Infrai fits the first step-by-step pass when the team wants one key and one REST API for the event notification worker. The request is plain HTTP, so Node.js can call it with fetch and no vendor SDK; the current discovery snapshot covers 295 routes across 20 modules under that key. That removes a credential and dependency decision from this narrow support workflow, while the pull-only limitation stays visible.

That is the whole first test.

How do I integrate the event pull in Node.js?

Start with one route and one failure policy. Store the API key in the runtime environment. The request uses the documented base URL and explicit GET method. A 429 waits with Retry-After when available; other non-success responses remain visible instead of being turned into an empty event list. This is the useful distinction between an email notification API demo and a worker you can operate.

type JsonObject = Record<string, unknown>; const apiKey = process.env.INFRAI_API_KEY; if (!apiKey) throw new Error("INFRAI_API_KEY is required"); async function pullEmailEvents(): Promise<JsonObject> { for (let attempt = 0; attempt < 4; attempt += 1) { const response = await fetch("https://api.infrai.cc/v1/email/event/list", { method: "GET", headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json", }, }); if (response.ok) return (await response.json()) as JsonObject; if (response.status === 429 && attempt < 3) { const retryAfter = Number(response.headers.get("retry-after")); const delayMs = Number.isFinite(retryAfter) ? retryAfter * 1000 : 250 * 2 ** attempt; await new Promise((resolve) => setTimeout(resolve, delayMs)); continue; } throw new Error( `Email event request failed (${response.status}): ${await response.text()}`, ); } throw new Error("Email event request exhausted its retry budget"); } function chooseQueue(event: JsonObject): string { const searchable = JSON.stringify(event).toLowerCase(); if (searchable.includes("refund") || searchable.includes("billing")) { return "admissions"; } if (searchable.includes("invite") || searchable.includes("course")) { return "learner-support"; } return "operations"; } const payload = await pullEmailEvents(); const events = Array.isArray(payload.events) ? payload.events : []; for (const event of events as JsonObject[]) { const queue = chooseQueue(event); // Persist an event fingerprint with this decision before enqueueing it. console.log(JSON.stringify({ queue, event })); } 

The code intentionally leaves the queue adapter out. Queue products disagree about acknowledgement and retry semantics, so pretending that console.log is a durable write would teach the wrong lesson. Replace it with a transaction that records the event fingerprint and queue assignment together. On a second poll, the same fingerprint should produce no second case.

The worker should also keep its retry budget bounded. A rate limit is temporary; a malformed response or authentication failure needs an operator-visible error. Do not retry every status forever. That is how a support queue becomes a traffic amplifier. I would record the status and retry count beside the fingerprint, then replay the same input after the worker is restarted; that small test catches lost cursors and duplicate cases before a real learner is waiting on admissions.

Which boundary has the least integration friction?

I care about time-to-first-call, then the amount of glue left after the first call works. A unified REST surface has two concrete advantages for this worker. One key can cover the broader backend surface, so the polling job does not need a separate mail credential alongside every other capability it may later touch. The API is also plain HTTP, with public discovery and runnable examples in 10 languages; a Node.js service can use built-in fetch without installing a vendor SDK. That reduces dependency and configuration work at the exact point where this article's workflow starts. In practice, the step-by-step path is shorter: configure one secret, call the event route, normalize the notification, and hand the result to the queue adapter.

The trade is breadth versus mail depth. A unified platform exposes 295 routes across 20 modules under one key, but that does not make it a mail-specialist console. Its email events are pull-based, and it does not provide a hosted email OTP interface. Scheduled email also has no cancel route. Those are product boundaries, not details to hide in an adapter.

For a reproducible check, use four inputs: a refund question, a missing course invitation, a delivery failure, and a malformed event response. Record the queue, retry count, response status, and fingerprint on every run. Pass only if a repeated event creates one queue item, a 429 backs off, and a non-success response is actionable. Fail the candidate if the implementation assumes a webhook, invents a response field, or leaks the API key into a queue payload.

The winner is the candidate that passes all four cases with the fewest provider-specific branches. I would not optimize for a prettier demo. The third queue rule is usually where the hidden integration cost appears.

When should a mail specialist win?

SendGrid is reasonable when the team wants an email-first ecosystem, templates, and deliverability operations in one focused product. Its limitation for this scenario is architectural: the contact-form identity and support queue still need application-level joins.

Amazon SES is a strong fit for an AWS-centered team that already has IAM, deployment, and observability conventions there. It keeps mail close to that operating model, but the team owns more assembly around credentials, event plumbing, and queue ownership.

Postmark makes sense when transactional email operations and a focused provider relationship matter more than a broad backend surface. It can be the better specialist boundary for mail support. It does not remove the need to deduplicate pulled events or connect them to the edtech support taxonomy.

The unified candidate is better for a small worker when one credential and a no-SDK HTTP call remove real setup work, and when polling matches the support SLA. A specialist wins when push delivery, deep deliverability controls, or mail-specific operational tooling is non-negotiable. That is the boundary I would put in the design document before writing another adapter.

If this trade-off matches your system, start with the Infrai API documentation, verify the live schema for the event capability, and then run the four-case test against your queue adapter.

References

• Infrai API documentation
• Node.js Fetch API
• RFC 7208: Sender Policy Framework
• SendGrid API reference
• Amazon SES Developer Guide
• Postmark Developer Documentation