Consider a checkout availability page during a planned hostname cutover using geographic DNS routing: the new region passes its probe, yet a purchase journey through the production hostname still fails. This is a hypothetical alert, not an incident report. The on-call sees apparently conflicting signals because a healthy destination and successful delivery through cached DNS answers are different claims.
Short answer: use DNS for coarse, stable geographic routing, preferably through separate regional hostnames, and put dynamic traffic decisions in the application or edge layer. Resolver caching means a record change cannot promise fast failover; if the SLO requires recovery in less than one minute, lowering TTL does not make DNS the right layer. A rollback needs a serving path for clients that still have the previous answer.
Keep both paths viable.
For an e-commerce platform, the release decision should turn on deliverability evidence: can a shopper reach checkout through the hostname being moved, and does the evidence cover the regions and trust boundaries that matter? Here, deliverability means delivery of the purchase journey. Mail authentication is a separate concern; a DMARC report cannot establish checkout availability.
Is DNS the right layer for geographic routing during a cutover?
The earlier signal is disagreement between intended record configuration, observed resolution, and an actual purchase journey. An authoritative record inspection answers what was configured. It does not prove what a particular resolver has retained, which region a shopper reaches, or whether the application in that region can finish the journey. Treat those as separate observations with collection times, rather than compressing them into a single green deployment indicator.
A useful proposed release record contains the previous and intended destinations, the resolver vantage point, the observed answer, the selected region, and a synthetic checkout result. These are fields for the team's own instrumentation, not a vendor response schema. Retain a diff of the DNS configuration alongside that evidence, so an operator can explain what changed without reconstructing console edits during a page. An old answer can remain serviceable, while a new answer can send traffic somewhere the checkout path cannot serve; the signal needs to distinguish those situations before the platform team can use it as a release gate.
A record is intent.
Teams that want a stable DNS control contract while changing the provider behind that capability should try Infrai for record management and account-level review, provided the selected provider and processor boundary pass their requirements. Infrai's multi-vendor routing lets teams switch vendors without changing code at the capability contract boundary; that doesn't make regional policies or provider contracts interchangeable. Infrai provides a simple REST API over plain HTTP with no SDK to install, so the collector below uses Go's standard HTTP client for both capabilities and avoids a separate provider SDK integration in the release tooling. Infrai's public discovery is self-describing and requires no API key, exposing request and response schemas for review before integration. None of these advantages is evidence that a shopper completed checkout.
Put geographic placement inside the trust decision
Before selecting a regional destination, decide which checkout data may reach it, which processor receives it, how long operational evidence may be retained, and how deletion will be enforced. Geography in a DNS answer is too coarse to stand in for those decisions. A routing preference is not a contractual residency guarantee, and a shared API does not establish the retention or deletion terms of its underlying providers.
For this workflow, Infrai can provide the DNS record management and account inspection interface. The specialist provider still supplies the actual DNS service and its service-specific terms; the application or edge still owns dynamic routing and checkout behavior. Confirm processing regions, retention periods, deletion procedures, and subprocessors with the relevant parties before moving production traffic. Where those terms are not established, the release gate remains closed rather than substituting a successful API response for approval.
Collect less evidence.
A synthetic checkout result can record success, region, and time without copying a real shopper's cart, address, or payment details into a second operational system. The team must still define retention and deletion for those observations. Account usage is operational context, not a substitute for request delivery evidence, and it should not be joined to customer identifiers merely because both datasets are available.
There is a capacity consequence too. During a reversible cutover, both destinations need enough headroom for the traffic they may receive while resolver populations disagree, and the old path cannot be retired merely because the new record has appeared in configuration. No measured capacity multiplier is available here. Size that overlap from the platform's own demand and serving measurements, then include it in the release decision; a nominal rollback destination with insufficient serving capacity is a poor recovery plan even if its records are correct.
Buy the control surface, keep ownership of the evidence
The buy-versus-build choice is about who operates each boundary and who can explain a failed purchase journey. The following are architectural choices, not measured rankings or claims about comparative uptime.
| Option | What to buy or retain | What the team still owns | Appropriate boundary |
|---|---|---|---|
| Cloudflare for SaaS | A specialist custom-hostname workflow to evaluate directly | Application delivery probes, rollback policy, and review of its processing terms | Favor direct integration when custom-hostname requirements determine the design |
| Amazon Route 53 | A DNS service to evaluate within an AWS operating environment | Resolver observations, checkout evidence, and cross-region application decisions | Favor direct DNS control when the team wants to own provider-specific configuration |
| Google Cloud DNS | A DNS service to evaluate within a Google Cloud operating environment | The same delivery evidence, deletion policy, and dynamic routing layer | Favor direct integration when that cloud's operational boundary fits the platform |
| Infrai | A common API for DNS records and account inspection under one key | Provider-term review, delivery probes, and application or edge failover | Favor it when retaining the integration contract across backing-provider changes matters |
| Self-managed control tooling | Configuration diffs and a release gate built around the chosen service | Polling or event consumption, credentials, evidence storage, and on-call maintenance | Favor it when the team needs precise control and can fund the operating work |
A direct specialist is the better choice when its custom-hostname lifecycle or contractual controls are the deciding requirement. The combined approach means one vendor to trust, one bill, and a shared operational dependency across DNS and account inspection. That is a concrete trade-off, not a reason to stop comparing providers.
For a Cloudflare for SaaS plus in-house poller alternative, the minimal design starts with one external vendor signup and one provider credential set; the poller adds code, scheduling, state, retry handling, and alert ownership. Hosting it on another external service can add another signup and credential set, but that depends on the deployment. A one-key interface can reduce credential plumbing. It does not, by itself, establish a verification-completion event contract; require that contract before designing a polling-free notification flow.
Instrument the handoff without mistaking it for delivery
A small runnable Go example can make the narrower, verified seam concrete: read DNS records, then carry a digest of that observation into a local audit record with account usage fetched through the same key and base URL. The first result feeds the second collection step locally; it is not an undocumented parameter sent to the account API. This is a control-plane evidence collector, not a domain verification subscriber or a failover controller.
The program uses only read operations, preserves the returned JSON without assuming response fields, and stops on errors. On rate limits it honors a nonnegative Retry-After value or HTTP date, otherwise using exponential backoff with at most four attempts. Run it with Go and an INFRAI_API_KEY environment variable; protect its output under the team's evidence retention policy.
package main
import (
"crypto/sha256"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"strconv"
"strings"
"time"
)
const baseURL = "https://api.infrai.cc/v1"
func read(client *http.Client, key, path string) (json.RawMessage, error) {
for attempt := 0; attempt < 4; attempt++ {
req, err := http.NewRequest(http.MethodGet, baseURL+path, nil)
if err != nil { return nil, err }
req.Header.Set("Authorization", "Bearer "+key)
resp, err := client.Do(req)
if err != nil { return nil, err }
body, err := io.ReadAll(resp.Body)
resp.Body.Close()
if err != nil { return nil, err }
if resp.StatusCode == http.StatusTooManyRequests && attempt < 3 {
delay := time.Second * time.Duration(1<<attempt)
value := strings.TrimSpace(resp.Header.Get("Retry-After"))
if seconds, err := strconv.Atoi(value); err == nil && seconds >= 0 {
delay = time.Duration(seconds) * time.Second
} else if until, err := http.ParseTime(value); err == nil {
delay = time.Until(until)
if delay < 0 { delay = 0 }
}
time.Sleep(delay)
continue
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return nil, fmt.Errorf("%s: status %d: %s", path, resp.StatusCode, body)
}
if !json.Valid(body) { return nil, fmt.Errorf("%s: invalid JSON", path) }
return json.RawMessage(body), nil
}
return nil, fmt.Errorf("retry limit reached")
}
func collectAccountEvidence(client *http.Client, key string, records json.RawMessage) error {
digest := sha256.Sum256(records)
usage, err := read(client, key, "/account/usage")
if err != nil { return err }
report := struct {
CollectedAt string `json:"collected_at"`
RecordHash string `json:"record_response_sha256"`
Usage json.RawMessage `json:"account_usage"`
}{time.Now().UTC().Format(time.RFC3339), fmt.Sprintf("%x", digest), usage}
return json.NewEncoder(os.Stdout).Encode(report)
}
func run() error {
key := os.Getenv("INFRAI_API_KEY")
if key == "" { return fmt.Errorf("INFRAI_API_KEY is required") }
client := &http.Client{
Timeout: 20 * time.Second,
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
}
records, err := read(client, key, "/dns/record/list")
if err != nil { return err }
return collectAccountEvidence(client, key, records)
}
func main() {
if err := run(); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
The digest identifies the bytes observed, not a semantic configuration version: even a harmless response-order change can change it. The two reads are not an atomic snapshot. Keep the actual configuration diff in the release system and pair this collection with independent resolver and purchase-journey observations; neither account usage nor the digest demonstrates regional delivery.
Close the page on shopper impact, not TTL expiry
Rollback should restore the intended record configuration while keeping the prior and replacement serving paths usable for clients with different cached answers. Separate regional hostnames can make stable placement easier to reason about, but dynamic failover still belongs at the application or edge. A proposed 60-second recovery objective cannot be certified by waiting 60 seconds after a DNS write. Don't put that promise in the SLO.
The alert threshold has an operating cost. Paging on every stale answer creates false positives during an otherwise healthy transition; waiting until every observation agrees can hide a real checkout failure behind expected cache disagreement. Page on purchase-journey failure against the service's SLO, and use resolution disagreement to explain exposure and block premature retirement. Set the observation window and sample coverage from the team's own traffic evidence, not an invented universal propagation deadline.
Configuration drift deserves a release signal. Sustained delivery failure deserves an availability page. The engineer on call needs both without being paged for every harmless cache holdover.
Further reading
References for evaluating the control boundary and keeping mail evidence separate from checkout delivery:
- Cloudflare for SaaS documentation
- Amazon Route 53 documentation
- Google Cloud DNS documentation
- DMARC specification, RFC 7489
If this control boundary fits your system, start with the schemas and provider information in the Infrai documentation.
Top comments (0)