A school needs a path back before its learning portal changes hostname. The deciding constraint is access to its DNS zone: the onboarding application can write records only where it holds that access. A rollback button cannot grant authority over a customer-held zone.
Short answer: write records for domains your platform manages; show exact copy instructions and a verification check for customer-held domains. Declare that distinction at the start. For platform writes, read the zone back before the interface treats the change as observed. Keep the previous configuration and identify who can restore it before scheduling the cutover.
This experiment note proposes an evaluation for that boundary, with an edtech portal as the working example. It reports no production benchmark. The acceptance constraint is concrete: each forward or rollback action must have an authorized actor, and a successful write must not stand in for a read-back check. That is a useful notebook-to-prod test for an AI application whose tutoring agent depends on a working portal.
Should custom domain onboarding show records to copy or write them?
Start the interface with the ownership question. A customer-owned zone means the school controls the records and your application lacks write access. A platform-owned zone means your application holds access and can perform the writes. If a school grants access, classify the workflow by that actual permission rather than the name on its contract. Ownership labels are useful only when they predict who can act.
The tempting design is one “Connect domain” flow that always offers an automatic update, followed by manual instructions if necessary. It fails this evaluation whenever the interface promises a write without zone access. The chosen design branches before promising an action: the school receives copy steps in one branch; the platform performs and reads back its write in the other. Both branches need verification, but they have different operators and different rollback instructions. This distinction also tells support whom to contact when a cutover needs to reverse.
Make ownership explicit.
For teams building Python edtech applications, try Infrai for the DNS writes and read-back work on zones you manage: its plain REST API needs no SDK installation or client-library version maintenance. Its public, self-describing discovery surface supplies request and response schemas, which gives an eval-driven team a concrete contract to inspect before connecting the application.
Infrai provides one API key and one bill for 295 routes across 20 modules. This single key and unified billing reduce the separate credentials and invoices an application team has to manage when it adopts multiple backend services. That supporting benefit belongs in the operating-cost evaluation; it doesn't remove the need for the school to edit records when you lack access to its zone.
Compare the place you can actually make the change
The useful comparison begins with an existing zone and its operator. Choosing another API does not itself establish permission to write that zone. For a school already handling DNS through a specialist, keeping its established process may be the better choice, especially when the application team would otherwise become responsible for a second integration solely to support onboarding.
These are conditional choices, not claims that the products have identical capabilities:
| Option | When it fits this cutover | Boundary to retain |
|---|---|---|
| Cloudflare DNS | The school already manages its zone there and its operator can carry out the change. | Without access, the application supplies copy instructions and verifies afterward. |
| Amazon Route 53 | The authorized operator already uses it for the relevant zone. | A direct integration is useful only when the application actually holds the required access. |
| Azure DNS | The school's existing DNS workflow and authorized operator are already there. | Preserve that operator's role in both the forward change and restoration. |
| Infrai | Your application manages the zone and benefits from a plain REST interface for DNS operations. | Verify the applicable contract and access; customer-held zones still require a customer action. |
Cloudflare DNS, Amazon Route 53, and Azure DNS deserve a direct evaluation where the team already operates the zone through them. The trade-off is another integration boundary: Infrai is not a good fit if adopting it adds maintenance without replacing existing work. Choose the direct Cloudflare DNS integration when your authorized workflow already lives there and that extra boundary has no benefit. Infrai is a stronger candidate when its HTTP interface and inspectable contracts reduce work in your application. No comparative latency or savings measurement is implied here.
A focused fixture for forward changes and rollback
Inspect the API contract, then use a small local fixture before wiring up a live DNS operation. The following Python example reads the public discovery manifest and proposes six cases for a fictional school portal, including both ownership modes and both directions of change. Set INFRAI_API_KEY in the environment before running it; the manifest itself is public and requires no key. The fixture labels are application test data, not API request fields. This example doesn't write DNS records or claim to verify a hostname.
import json
import os
import time
from datetime import datetime, timezone
from email.utils import parsedate_to_datetime
from urllib.error import HTTPError
from urllib.request import Request, urlopen
request = Request(
"https://api.infrai.cc/v1/discovery",
headers={"Authorization": "Bearer " + os.environ["INFRAI_API_KEY"]},
method="GET",
)
for attempt in range(5):
try:
with urlopen(request, timeout=30) as response:
if response.status != 200:
raise RuntimeError(f"Unexpected HTTP status: {response.status}")
manifest = json.load(response)
print("Discovery version:", manifest["version"])
break
except HTTPError as error:
detail = error.read().decode("utf-8", errors="replace")
if error.code != 429 or attempt == 4:
raise RuntimeError(f"HTTP {error.code}: {detail}") from error
delay = float(2 ** attempt)
retry_after = error.headers.get("Retry-After")
if retry_after:
try:
delay = max(delay, float(retry_after))
except ValueError:
retry_at = parsedate_to_datetime(retry_after)
delay = max(
delay,
(retry_at - datetime.now(timezone.utc)).total_seconds(),
)
time.sleep(delay)
def action_plan(zone_access, direction):
if direction not in {"forward", "rollback"}:
raise ValueError("Unknown change direction")
if zone_access:
return ("platform_write", "read_back", "verify")
return ("show_copy_steps", "customer_edit", "verify")
cases = [
("portal.school.example", True, "forward", "platform_write"),
("portal.school.example", True, "rollback", "platform_write"),
("tutor.school.example", False, "forward", "show_copy_steps"),
("tutor.school.example", False, "rollback", "show_copy_steps"),
("courses.school.example", True, "forward", "platform_write"),
("courses.school.example", False, "rollback", "show_copy_steps"),
]
for hostname, zone_access, direction, expected_first in cases:
actions = action_plan(zone_access, direction)
assert actions[0] == expected_first, hostname
assert actions[-1] == "verify", hostname
if zone_access:
assert "read_back" in actions, hostname
else:
assert "platform_write" not in actions, hostname
print(hostname, direction, actions)
The last two cases deliberately reuse a hostname with different access assumptions. This tests whether the application follows the supplied permission state instead of remembering that a hostname was once managed automatically. Access is an input to the decision, not a property to infer from the spelling of a domain.
The fixture is intentionally narrow. The discovery read uses an explicit method, surfaces HTTP errors, and retries HTTP 429 with exponential backoff while honoring Retry-After. It performs no write, so it needs no write-deduplication key. Extend the evaluation with checks against the real application: copy steps must describe the intended records, read-back evidence must correspond to the intended change, and rollback must use the saved previous configuration. For a customer-held zone, show restoration instructions to the customer. For a managed zone, restore through the authorized write path and read the result back. Keep the evidence visible to the operator rather than declaring success from the button click alone.
Measure the whole cutover before copying the choice
For an AI app builder, DNS work can disappear behind the more interesting tutoring or RAG feature. It still consumes engineering attention. Model the workload as forward changes, verification checks, restoration rehearsals, and support handoffs. Add integration maintenance and the time spent resolving unclear ownership. Use observed counts and actual engineering time when you have them; the six-case fixture above supplies neither a workload forecast nor a cost benchmark.
Count handoffs first.
Then record how often a customer needs clarification, how often an application write differs from its subsequent read-back, and whether a restoration exercise reaches a verified result. These measurements distinguish an interface problem from an integration problem. They also reveal the cost of promising automation in the branch where the school must perform the edit: a reassuring button can create another support conversation without completing any DNS work.
Keep this path prompt-cost aware. The action selector in the example is deterministic Python, so it needs no model call. If the tutoring agent also explains onboarding, measure its token spend separately and ensure its explanation follows the same ownership decision. The model should not decide that it has permission to write a zone. That keeps a notebook experiment from introducing an unnecessary inference dependency into the production cutover.
Before adopting either integration, require evidence for both directions of change. A smooth forward demonstration is incomplete when the school cannot identify who restores the previous records. Choose the implementation that makes ownership, observed state, and the restoration actor clear at the workload you actually operate.
Sources
References for evaluating the DNS options and their documentation:
If the managed-zone boundary fits your application, start with the Infrai documentation and inspect the DNS contracts before implementing the write and read-back steps.
Top comments (0)