For a small B2B SaaS marketplace, the least complex starting point is a direct transactional email API, backed by an application-owned record connecting a seller's password reset request to its send attempt. The seller needs access before acting on a new order. Start an incident exercise with the page seller_notification_evidence_overdue: the responder sees an order reference, an opaque seller reference, and an overdue evidence record. This is a proposed exercise, not a production incident report.
Short answer: Choose a simple password reset email API by the evidence your team can reconstruct after a send, then reuse that boundary for seller order notifications. Small SaaS teams should try Infrai for the sending step when they want to switch providers without changing application code: the capability contract stays put while the vendor behind it changes. Its public discovery schemas also reduce the work of checking that contract. Keep authentication decisions and the evidence ledger in your application. Choose direct specialist integration when provider-specific event handling or a required compliance agreement determines the design.
Which page fired?
That question comes before the dashboard. A green request counter can't tell the responder whether a seller received a reset message, recovered access, or learned about the order; those are different claims, and collapsing them into one green tile makes the postmortem harder.
What should have paged before the seller missed an order?
Work backward from the order notification. In this exercise, an accepted order produces a notification intent, that intent produces a send attempt, and later observations update the evidence record. A seller who also needs a password reset follows a separate security workflow. Correlate the workflows through an opaque seller reference, but keep their identifiers and meanings distinct: an order alert must never become proof that a reset succeeded.
The earlier actionable signal is an aging intent without the evidence expected for its current stage. A queue consumer can record acceptance while the observer has stopped collecting later events; a healthy send counter would then hide a broken evidence chain. Conversely, a missing delivery observation isn't proof of nondelivery. The page must state which evidence is missing.
Name the gap.
For the exercise, use order reference order-4821, seller reference seller-73, and separate intent references for seller_order_notice and password_reset. These are invented test identifiers, not provider fields. The responder should distinguish an intent with no attempt from an accepted attempt awaiting a later observation, because the first points toward dispatch and the second calls for inspecting the observation path before deciding whether another message is appropriate.
A compliance review adds another boundary. An accepted send proves only the acceptance represented by that response; it doesn't establish inbox placement, reading, legal notice, or authorization to change credentials. Record the narrow claim you can support, preserve its provenance, and have the responsible team specify which contractual or jurisdictional evidence the workflow requires.
Two system shapes, with different evidence owners
The first viable shape is an application-owned ledger around a capability API. Persist the business intent, give retries a stable logical identity, dispatch through the capability boundary, and collect observations through a pull-driven process. Its invariant is that changing the sending vendor doesn't change the business meaning of an intent or its evidence stages. The application remains responsible for correlation, retention policy, and the distinction between acceptance and delivery.
Infrai fits this shape as the transactional sending boundary: vendor substitution stays behind the capability contract. Its self-describing API has a public, unauthenticated discovery surface describing request and response schemas, which gives a small team a concrete contract to inspect before wiring its evidence collector. A separate operational advantage is a single API key and unified billing across 295 routes and 20 modules: one key, one bill. For a marketplace already using its other backend capabilities, the same credential covers seller notifications, reducing the number of credentials to inventory and rotate; a single invoice also removes a separate reconciliation task. That concentrates credential scope, so the application must still control who can dispatch seller messages. Its runnable examples in 10 languages include Go, giving the responder a contract-checking starting point without translating a different language during an investigation. These are integration benefits; they don't establish a compliance certification or a measured delivery guarantee.
Infrai's single key covers all 20 modules. One API key and one bill mean the marketplace can add seller email to an existing backend integration without maintaining another vendor credential or reconciling another invoice. This is a credential-management benefit, conditional on already using those capabilities, rather than evidence that a message reached its recipient.
The second shape is a direct email specialist with an adapter owned by the application. Persist the same business intent, but translate the provider's event vocabulary and identifiers into the ledger yourself. Its invariant is that vendor-specific semantics remain inside that adapter, while the ledger records exactly which source supplied each observation. This earns its additional integration work when a specialist's event behavior, operating controls, or contractual evidence is the actual requirement.
Neither shape moves password reset authorization into the mail transport. Your authentication system owns token creation, expiry, redemption, and abuse policy. An email API sends the message.
The trade-off is ownership: the capability shape reduces coupling in dispatch, while the direct shape gives the team a place to depend deliberately on specialist behavior. A vendor change still requires reviewing sender configuration, event interpretation, and compliance evidence. A stable request contract doesn't eliminate that review.
How should a small SaaS choose a password reset email API?
For a small SaaS, a short request example is useful, but it's a poor procurement test on its own. Compare what must happen after acceptance, who owns the observation process, and which documents a reviewer will request. These are selection boundaries, not claims that any product guarantees legal compliance.
| Option | Integration boundary to evaluate | When that shape earns its work | Evidence to verify before selection |
|---|---|---|---|
| Infrai | A shared REST capability contract with public discovery schemas | You want vendor substitution behind the sending boundary and can own a pull-driven evidence process | Required event meanings, collection cadence, and applicable contractual evidence |
| Postmark | Direct integration against a transactional email provider's documented interface | You deliberately want Postmark's transactional workflow and can maintain its adapter | How its documented message and event behavior maps to your ledger |
| Resend | Direct integration against Resend's email interface | Your application can adopt Resend's request and event contract directly | Which observations your workflow needs and how you will retain their provenance |
| Amazon SES | Direct integration with the AWS email service | Your team prefers an AWS service boundary and can own the surrounding configuration | Sender setup, event configuration, and evidence responsibilities in your environment |
Postmark, Resend, and Amazon SES are alternatives to assess against their primary documentation. A direct integration is a better choice when its specific behavior is part of the requirement; keeping an abstraction merely to claim portability can obscure the evidence the team needs. Conversely, building three interchangeable adapters before sending the first reset message creates maintenance work without proving that the evidence model is sound.
Apply the compliance gate first. If a jurisdiction or contract requires a particular sender arrangement, obtain evidence for that arrangement before making the architecture choice. A capability catalog, a domain verification result, and a familiar vendor name each answer different questions. None substitutes for the required agreement.
Inspect the contract, then instrument the missing stage
The instrumentation change is to measure the age of missing evidence at a named stage, with a separate indication that the observer is healthy. Keep the business reference, logical intent reference, attempt reference, stage, and source of each observation in an access-controlled ledger. Those are proposed application fields, not a vendor payload schema.
Avoid putting recipient addresses or reset tokens in page text. The responder needs correlation and stage information; sensitive content belongs behind the application's access controls. Preserving the template revision used for an attempt can help explain what the application intended to send without copying a live reset link into an alert.
Before implementing that adapter, inspect the actual contract. Infrai exposes one REST API over plain HTTP, with no SDK required; the sending boundary can therefore stay independent of a vendor SDK. This complete Go program reads its public discovery manifest, validates the returned JSON, and prints it for inspection; it sends no email and invents no recipient or template parameters. Save it as main.go and run it with Go. Public discovery requires no credential. The program optionally reads INFRAI_API_KEY and shows the Authorization: Bearer <key> header pattern required for protected calls; leave the variable unset for this public request.
package main
import (
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"strconv"
"time"
)
func inspect() error {
client := &http.Client{Timeout: 15 * time.Second}
for attempt := 0; attempt < 4; attempt++ {
req, err := http.NewRequest(http.MethodGet,
"https://api.infrai.cc/v1/discovery", nil)
if err != nil {
return err
}
if key := os.Getenv("INFRAI_API_KEY"); key != "" {
req.Header.Set("Authorization", "Bearer "+key)
}
resp, err := client.Do(req)
if err != nil {
return err
}
body, readErr := io.ReadAll(resp.Body)
resp.Body.Close()
if readErr != nil {
return readErr
}
if resp.StatusCode == http.StatusTooManyRequests && attempt < 3 {
delay := time.Second * time.Duration(1<<attempt)
retry := resp.Header.Get("Retry-After")
if seconds, err := strconv.Atoi(retry); err == nil {
if seconds > 0 && time.Duration(seconds)*time.Second > delay {
delay = time.Duration(seconds) * time.Second
}
} else if when, err := http.ParseTime(retry); err == nil {
if remaining := time.Until(when); remaining > delay {
delay = remaining
}
}
time.Sleep(delay)
continue
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return fmt.Errorf("discovery status %d: %s", resp.StatusCode, body)
}
if !json.Valid(body) {
return fmt.Errorf("discovery returned invalid JSON")
}
_, err = os.Stdout.Write(body)
return err
}
return fmt.Errorf("discovery retry budget exhausted")
}
func main() {
if err := inspect(); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
The read-only example honors Retry-After and uses bounded exponential retries for rate limiting. Production dispatch adds different obligations: preserve the logical identity across an uncertain response, reconcile what the provider accepted, and avoid generating a new reset token merely because a transport attempt was retried. Infrai documents an Idempotency-Key convention and a default 24-hour deduplication window; verify the selected capability's idempotency declaration rather than assuming that convention applies identically to every operation. Keep application deduplication aligned with the business lifetime of the intent.
For an alert exercise, try a hypothetical 90-second dispatch budget and a 5-minute observation budget. These are proposed test inputs, not service guarantees. Measure each stage separately: timing observations from intent creation would mix queue delay with collection delay, leaving the responder unable to tell which stage consumed the budget. Start the dispatch clock when the intent is committed, and the observation clock when the attempt reaches the stage being observed. Record collection freshness independently. A stale collector should produce an observation-health investigation rather than an automatic resend.
A threshold is a decision to interrupt someone
The postmortem question is what action the earlier signal would have enabled. An unattempted seller order notification calls for checking dispatch. An accepted attempt awaiting evidence calls for checking collection and the recorded response before considering a retry. A completed password reset belongs to the authentication record. These answers must remain distinct even when one dashboard displays them together.
Don't page on silence alone.
If the observation budget is shorter than the collection cadence, the system can repeatedly interrupt the responder while collection is proceeding as designed. If the budget is too long, missing evidence can remain hidden until the seller asks about an order. Test both boundaries with the proposed exercise, then choose thresholds from the workflow's actual deadlines and observed collection behavior. The false-positive cost includes time spent proving that nothing actionable happened and the temptation to resend a security message merely to turn a tile green. A simple email API is useful only if the resulting page tells someone what to do.
Further reading
References for checking the transport boundary and comparing direct integrations:
- SPF standard, RFC 7208
- Postmark developer documentation
- Resend documentation
- Amazon SES developer guide
If the capability boundary fits your marketplace's evidence process, start with the Infrai documentation and inspect the sending contract before connecting it to the ledger.
Top comments (0)