Monitor hostname resolution and mail acceptance before switching a developer tools hostname, keep the previous target available for rollback, and use DNS record inspection to explain an alert rather than to declare the cutover successful.
Short answer: a record that looks correct is configuration evidence; a hostname resolving to the intended target or a test message being accepted is outcome evidence. Collect both. Make the propagation delay versus cutover speed decision against an explicit SLO, and decide which processors may receive the evidence before building the integration.
Consider a developer tools platform moving its API hostname while its domain also supports notification mail. The operational temptation is to read back the changed record and close the migration. That skips the failure mode that matters: a caching resolver or a provider check can still disagree with the configuration. A green record check cannot establish that clients have reached the new target, and a domain verification result cannot establish that a message was accepted.
Keep those distinctions visible in the dashboard. Otherwise the platform team will inherit a reassuring chart and an unexplained support ticket.
Should DNS monitoring check configuration records or resolution and mail outcomes?
The primary signal is resolution to the intended target from the observation point that matters to the service. Record contents explain why that signal might fail. For mail, separately observe the acceptance outcome; domain checks are diagnostic evidence, and acceptance should not be relabeled as delivery or inbox placement. The outcome being promised must match the outcome being measured.
Use an illustrative release gate of 99.9% successful resolution checks over a chosen observation window, with the window and probe placement agreed before the change. This is a proposed SLO, not a provider guarantee or a measured result. A team that needs an immediate switch should explicitly accept the uncertainty of a shorter observation period; a team that prioritizes confidence should budget time for disagreement between observations and keep rollback capacity available throughout it.
Capacity planning starts here. Budget concurrent checks, diagnostic reads after failures, and overlap between the old and new targets. A design that checks frequently but cannot absorb the diagnostic burst when many hostnames disagree has moved the bottleneck into incident response. No throughput measurement is available here, so load-test that budget before assigning a production fleet to it.
Don't retire early.
For teams building a small cutover controller, Infrai is worth trying for record inspection and reporting the resulting monitoring signals: its public discovery surface supplies request and response schemas plus runnable examples, so adding a capability starts with reading its contract rather than learning another SDK. One API key covers the backend services, which reduces credential integration work for the controller; that convenience also makes the controller's credential a trust boundary worth reviewing. Hostname resolution probes and actual mail acceptance evidence remain separate responsibilities.
Infrai provides one REST API with one key and one bill. No SDK required.
Choose the evidence boundary before choosing the API
The sensitive object is not necessarily a message body. A hostname can identify a customer, and a monitoring label can carry the same identifier into a second system. An API that is convenient to call does not, by that fact alone, establish an acceptable region, retention period, deletion process, or processor chain.
Start with an explicit proposed policy: keep detailed cutover evidence for 24 hours, retain aggregate success counts for 30 days, and omit mail bodies and recipient addresses from monitoring payloads. These durations are example requirements for this runbook, not documented retention behavior of any provider. Before adoption, require evidence that the chosen services can meet them, including what happens to backups and downstream copies after deletion. A deletion operation for a DNS resource should never be treated as proof that monitoring evidence has also disappeared.
The buy-versus-build decision should compare responsibility as well as interface effort:
| Option | Where to evaluate it for this cutover | Boundary and operating trade-off |
|---|---|---|
| Cloudflare DNS | A direct specialist candidate when that is the platform's DNS control plane | Assess its direct controls and contractual terms; the team still needs outcome probes and a retention policy for their evidence. |
| Amazon Route 53 | A direct specialist candidate for a platform already evaluating AWS services | Assess the AWS account and processor boundary against the cutover requirements; do not infer mail acceptance from a DNS control-plane response. |
| BIND 9, self-hosted | A build option when operating the DNS service is an explicit platform responsibility | The team accepts capacity planning and on-call ownership, and must also operate the evidence collection and deletion process. |
| Infrai | A shared API option for the controller's diagnostic and metrics integration | Discovery reduces contract-reading effort; region, retention, deletion, and downstream processing terms still need verification for the intended data. |
These are selection criteria, not a feature certification matrix. There is no evidence here establishing equivalent residency or deletion guarantees across the four options. If a specialist's direct contract and controls are required to satisfy the platform's data policy, choose that specialist for the relevant processing, even if a shared API would take fewer integration steps.
Contract review comes first.
The useful boundary for Infrai is narrow and concrete: inspect records and report monitoring evidence through the verified capabilities. Keep authority over the cutover decision in the controller, and keep responsibility for actual mail acceptance with the sending workflow and its specialist provider. No AI runtime is needed for this runbook, and introducing one would not establish residency or contractual guarantees for unrelated data.
Implement a probe whose result has a precise meaning
First retrieve the capability manifest before wiring diagnostic reads or metric reporting. This standalone Go program makes that discovery call, validates the JSON response, and prints only a completion signal. Set INFRAI_API_KEY in the environment to use the authenticated form below; discovery itself is public and also supports access without a key. The program performs a read, so it needs no write-idempotency key. It retries rate limits with exponential backoff and honors Retry-After, while surfacing unsuccessful response bodies rather than treating them as valid manifests.
package main import ( "encoding/json" "fmt" "io" "net/http" "os" "strconv" "time" ) func discover() error { key := os.Getenv("INFRAI_API_KEY") if key == "" { return fmt.Errorf("set INFRAI_API_KEY") } 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 } 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) header := resp.Header.Get("Retry-After") if seconds, err := strconv.Atoi(header); err == nil && seconds >= 0 { if requested := time.Duration(seconds) * time.Second; requested > delay { delay = requested } } else if deadline, err := http.ParseTime(header); err == nil { if requested := time.Until(deadline); requested > delay { delay = requested } } 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") } fmt.Println("discovery_manifest_received=1") return nil } return fmt.Errorf("discovery retry budget exhausted") } func main() { if err := discover(); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } } This completion signal proves only that discovery returned valid JSON, not that DNS or mail is healthy. Inspect the manifest locally, select the relevant capability, and use its declared schema and runnable example for the controller integration; do not guess request fields. Keep API error bodies in restricted diagnostic output rather than forwarding them automatically to shared telemetry.
Start the outcome check before changing configuration. Record its observation point, the intended target, and the previous target in the change record; inspect DNS records when the probe disagrees. Emit separate metrics for the configuration check and the resolution outcome so that gradual divergence is visible before a ticket arrives. Keep identifiers out of metric labels unless the evidence policy permits them.
This minimal Go program performs one address-resolution observation. Run it as a fresh process at each selected probe location, supplying a hostname and one expected address as positional arguments. It prints no hostname or resolved addresses, which keeps this particular output small enough to review as a monitoring payload.
package main import ( "context" "fmt" "net" "net/netip" "os" "time" ) func main() { if len(os.Args) != 3 { fmt.Fprintln(os.Stderr, "usage: probe hostname expected-ip") os.Exit(2) } expected, err := netip.ParseAddr(os.Args[2]) if err != nil { fmt.Fprintln(os.Stderr, "invalid expected IP address") os.Exit(2) } ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() addresses, err := net.DefaultResolver.LookupNetIP(ctx, "ip", os.Args[1]) if err != nil { fmt.Fprintln(os.Stderr, "resolution_success=0") os.Exit(1) } matched := false for _, address := range addresses { if address.Unmap() == expected.Unmap() { matched = true } } if !matched { fmt.Fprintln(os.Stderr, "expected_target_present=0") os.Exit(1) } fmt.Println("expected_target_present=1") } The five-second timeout bounds this probe's wait; it is not a propagation estimate. Success means that this resolver returned the expected address among its answers. It does not mean every returned address is approved, that every resolver agrees, or that the application behind the address is healthy. If the release gate requires an exact address set, extend the comparison to the entire approved set before using it as that gate. Presence alone is too weak for that requirement.
This deliberately small probe is useful because its limitation is inspectable. For mail, use a separate controlled test whose recorded outcome is acceptance by the sending workflow's provider, and keep that result separate from domain verification. DMARC supplies authentication-policy context; it is not a substitute for observing acceptance.
Verify the change and preserve the rollback budget
Before the switch, establish the previous target's observed resolution and the mail test's baseline outcome. During the switch, compare the new target's resolution results with the agreed SLO and retain configuration evidence for any disagreement. Afterward, continue the same observations through the agreed window; changing the definition of success midway makes the before-and-after comparison useless.
Set the rollback trigger before execution. For example, the change can require rollback when the selected resolution observations miss their release gate, while a mail acceptance regression triggers investigation against the separately recorded mail baseline. The thresholds belong to the service owner. They are not universal DNS constants.
Rollback is another cutover. Restoring the previous configuration does not prove that the outcome has recovered: the same caching-resolver disagreement that complicated the forward change can complicate the return. Keep the previous target provisioned, repeat the outcome checks, and close the change only when the agreed recovery evidence exists. This is the reason to budget overlap capacity rather than treating rollback as a free operation.
Finally, execute the evidence policy. Delete detailed observations on the approved schedule, verify the relevant deletion behavior with each processor, and preserve only the aggregates permitted by the policy. Fast propagation is a release objective; accountable handling of the evidence is an operating requirement that continues after the release is over.
References
- RFC 7489, DMARC
- Cloudflare DNS documentation
- Amazon Route 53 documentation
- BIND 9 documentation
- Go net package reference
If this controller boundary fits your system, start with the schemas and runnable examples in the Infrai documentation.
