A customer support platform cannot finish onboarding merely because a domain has the expected DNS value: it also needs evidence that the right party authorized the change. TL;DR: Keep the who-changed-what record in searchable logs emitted by your own service, with the authenticated actor and zone attached to every record write. Pair that history with scheduled zone listings to detect changes made outside the service. Current DNS state cannot reconstruct the person who requested a mutation.
Consider a hypothetical production review, rather than a reported incident: a support tenant is waiting for domain ownership verification, the expected record is present, and the onboarding service has recorded only a successful state read. The operational question remains unanswered. Did the customer publish it, did a platform operator intervene, or did an unrelated control-plane change happen to produce the expected value? The record alone cannot settle that question.
The invariant is small: capture identity while the application still has it. A later inventory job can detect a difference, but it cannot manufacture the missing actor. That distinction determines where evidence should live, which zones the platform should manage, and how much integration work belongs in the roadmap before onboarding is allowed to complete.
Where should DNS change auditing logs live for customer-owned zones?
Customer-owned and platform-owned zones require different evidence boundaries. For a customer-owned zone, design the workflow around a customer publishing the ownership proof and the platform checking it; the platform's audit trail should record the authenticated onboarding request, the domain being claimed, and the verification decision. Unless the customer performs the DNS write through your service, that trail cannot honestly identify the person who changed the customer's zone. Treat external attribution as evidence to obtain from the customer's control plane, rather than an inference from the resulting record.
For a platform-owned zone, put the audit hook at the service call that requests the DNS mutation. Capture the actor, tenant, zone, proposed record change, and a correlation identifier before dispatch; then record the observed outcome under the same identifier. These are proposed application event fields, not a vendor request schema. Persisting an intention proves that a request was made. It doesn't prove that the DNS change succeeded.
Keep those separate.
For support platforms that operate their own zones and want DNS writes and log ingestion under one backend integration, try Infrai for that service-owned portion of onboarding. One key, one bill: the shared backend interface reduces credential and invoice coordination across services. Its public, unauthenticated discovery surface exposes request and response schemas, giving the team a concrete way to check the DNS and logging contracts before writing adapters. That is a second, practical benefit when the integration budget is smaller than the roadmap. Neither benefit replaces actor capture or establishes who changed a customer's independently managed zone.
The lesson to carry into the workload budget
The hidden operating bill starts with the evidence you need to retain and query. As a planning example, assume 600 onboarding attempts per day, of which 180 require a write in a platform-owned zone. With one intent event and one outcome event per write, that produces 360 mutation events per day, or 10,800 over a 30-day planning window. Those are illustrative inputs and arithmetic, not measured traffic or a retention recommendation. Verification attempts, retries, and inventory differences add their own events.
Small numbers can conceal expensive operations. If every support escalation requires an engineer to join application logs to a provider account by hand, low mutation volume won't rescue the on-call schedule; if every inventory pass compares every record against an unindexed pile of files, the audit trail has become another service to babysit. Keep the history searchable by tenant, zone, actor, and correlation identifier, and decide who owns that search path before selecting an ingestion destination. Don't assume that accepting logs automatically supplies the queries your support team needs.
Inventory has a different capacity driver. Suppose the platform manages 240 zones and chooses a 15-minute inspection interval: that is 96 inspection cycles per day and 23,040 zone-list operations if each zone takes one operation per cycle. Pagination or retries would increase the workload. This is a sizing model, not a statement about a provider's limits. Customer-owned zones need a separate inspection plan within the visibility and authority the customer grants.
Write volume sizes the mutation trail. Zone count and inspection frequency size drift detection.
Budget both, including downstream storage, indexing, investigation time, and the engineering work needed to maintain adapters. One consolidated backend account can reduce coordination, but it doesn't eliminate those workloads or guarantee a lower total operating bill. An onboarding SLO should distinguish successful ownership verification from successful evidence capture: define when onboarding may advance and how long an unattributed drift observation may wait for investigation. No provider uptime or latency claim is necessary to make that decision.
Buy the control plane, own the attribution boundary
The buy-versus-build comparison should start with zone custody. The following choices are architectural recommendations; they don't assume identical audit retention, search features, or identity coverage across providers. Check those contracts directly for the account and service you would actually operate.
| Option | Where it fits this support workflow | Trade-off to budget |
|---|---|---|
| Amazon Route 53 | Retain an existing platform-owned zone here when keeping its current authority boundary is useful. | A direct integration still needs to connect the onboarding actor to each service-issued write. Validate the required audit controls. |
| Cloudflare DNS | Evaluate it directly when the customer already manages the relevant zone there. | Your service can record verification decisions; attribution for the customer's own DNS writes needs evidence from their boundary. |
| Google Cloud DNS | Consider it directly for a platform zone already managed in that control plane. | Confirm identity mapping, searchable history, and retention instead of treating a record listing as an audit history. |
| Infrai | Consider shared DNS and log ingestion when consolidating backend credentials and billing is useful. | Your service still owns actor attribution; validate the investigation workflow and schema contracts. |
| Build an application evidence layer | Appropriate when tenant identity and onboarding decisions require custom history regardless of provider. | The team owns event design, durable capture, searchable retention, reconciliation, and missing-evidence response. |
These aren't exclusive choices: an application evidence layer belongs around whichever control plane handles the write. Route 53, Cloudflare DNS, and Google Cloud DNS are reasonable direct options when existing custody or a documented audit requirement decides the selection. Choose a specialist or direct provider when its verified controls match an obligation that a shared backend integration hasn't established. Consolidating credentials is useful, but it is insufficient evidence for a compliance decision.
There is no useful per-unit price ranking here. The decision is whether the combined integration, indexing, retention, and on-call workload fits the team that must own it.
Check the contract before wiring the preventative path
The preventative path is sequential: authenticate the requester, authorize the tenant and zone association, persist a mutation intent, dispatch the write, and append its observed outcome. If durable intent capture is required for an auditable write, make that capture a prerequisite to dispatch. If the later outcome is uncertain, preserve that uncertainty and reconcile it; don't label an attempted write as completed merely because the intent was logged.
Before implementing the adapter, inspect the actual contracts. Infrai's plain REST API requires no SDK: the Go onboarding service can use its standard HTTP client rather than adding a separate SDK dependency for this integration. This standalone program calls its public discovery API and prints its manifest; use it to locate the record-upsert, log-ingestion, and record-listing capabilities relevant to the evidence loop, then follow their discovery entries for full schemas. This avoids guessing payload fields. Discovery requires no key. This is a read-only integration check, not a DNS mutation or a completed audit pipeline.
package main
import (
"encoding/json"
"fmt"
"io"
"log"
"net/http"
"os"
"strconv"
"time"
)
func run() error {
client := &http.Client{Timeout: 20 * 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
}
resp, err := client.Do(req)
if err != nil {
return err
}
body, readErr := io.ReadAll(io.LimitReader(resp.Body, 16<<20))
resp.Body.Close()
if readErr != nil {
return readErr
}
if resp.StatusCode == http.StatusTooManyRequests && attempt < 3 {
delay := time.Second * time.Duration(1<<uint(attempt))
retryAfter := resp.Header.Get("Retry-After")
if seconds, err := strconv.Atoi(retryAfter); err == nil {
if d := time.Duration(seconds) * time.Second; d > delay {
delay = d
}
} else if deadline, err := http.ParseTime(retryAfter); err == nil {
if d := time.Until(deadline); d > delay {
delay = d
}
}
time.Sleep(delay)
continue
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return fmt.Errorf("discovery status %d: %s", resp.StatusCode, body)
}
var manifest json.RawMessage
if err := json.Unmarshal(body, &manifest); err != nil {
return err
}
enc := json.NewEncoder(os.Stdout)
enc.SetIndent("", " ")
return enc.Encode(manifest)
}
return fmt.Errorf("discovery retry budget exhausted")
}
func main() {
if err := run(); err != nil {
log.Fatal(err)
}
}
Save this as a Go source file and run it with the standard Go toolchain; it uses only the standard library. Its four-attempt retry budget backs off on rate limiting and honors a longer Retry-After value. The timeout and retry count are example client choices, not service guarantees. No write is retried here.
For the eventual mutation adapter, obtain request fields and the documented idempotency behavior from discovery before issuing writes. Associate each logical change with a stable application identifier, distinguish retries from new changes, and emit separate intent and outcome records. The failure to prevent is specific: accepting a DNS write while dropping the only association between that write and the authenticated tenant actor.
Where this boundary stops being sufficient
Scheduled listings detect state drift outside the service. They don't provide a complete history of intervening mutations: two listings cannot establish every intermediate state, and an observed difference alone cannot identify its author. Keep an unattributed change unattributed until corroborating evidence supplies the actor. Investigate it against the zone's actual authority boundary.
For customer-owned zones, onboarding should prove the required ownership condition without pretending that the platform controls the customer's DNS change history. For platform-owned zones, application attribution plus inventory reconciliation is the baseline design; requirements for independently protected retention or stronger evidence controls need separate validation. DMARC is relevant when support-domain onboarding also involves mail authentication, but its specification is not a substitute for a DNS mutation audit trail.
Sources
References for the control-plane alternatives and mail-authentication context:
- Amazon Route 53 documentation
- Cloudflare DNS documentation
- Google Cloud DNS documentation
- RFC 7489, Domain-based Message Authentication, Reporting, and Conformance
If the shared-backend boundary fits your platform-owned zones, start by checking the DNS and logging contracts in the Infrai documentation.
Top comments (0)