Use the Name, Route, Prove, Operate framework, a worked example, and a downloadable worksheet to turn a DNS change into an evidence-backed client deliverable.

A custom domain client website setup looks like a small DNS task. The risky version is small: someone copies a value into an unfamiliar dashboard, removes a record that appears to conflict, sees the homepage load once, and calls the job finished.

I would treat it as a controlled connection between four different things: the client's registered domain, the authoritative DNS service, the website platform, and the public origin the application will use. The DNS records are only the middle of that chain.

The acceptance test is not simply “the domain resolves.” It is: the exact hostname reaches the intended release over valid HTTPS, alternate hostnames behave deliberately, important journeys still work, and the client knows who owns every account needed to keep it working.

The operating rule: copy the current platform-provided records exactly, change only the records in scope, and accept the connection from the live hostname rather than from the DNS dashboard.

Use four stages for a custom domain client website connection

I use a four-stage framework: Name, Route, Prove, Operate. It is short enough for a project plan, but each stage produces evidence that the next person can inspect.

StageDecisionEvidenceTypical blocker
NameWhich exact hostname is public and canonical?Connection brief with apex, www, staging URL, and release IDThe client says “use our domain” without choosing the public origin
RouteWhich exact DNS records should change?Before-state inventory and platform-provided record setThe wrong DNS provider is edited or an unrelated record is removed
ProveDoes the platform own, route, and secure the hostname?Verified status, valid certificate, redirects, and live journey checksA lookup succeeds, but TLS or application behavior is still pending
OperateWho keeps the connection healthy?Named account owners, renewal owner, support path, and rollback recordThe domain or DNS remains tied to one person's login

This is not extra ceremony for its own sake. It prevents a technical action from becoming an undocumented ownership transfer. It also gives an agency a clear deliverable that fits beside the broader client website launch checklist.

Name the exact public hostname before touching DNS

Start by writing the complete public origin, including the scheme and hostname. For example, decide whether the canonical origin will be https://example.com or https://www.example.com. Then decide what the other version should do.

“The domain” is too vague because several related names may exist:

  • Apex domain: the bare name, such as example.com.
  • Subdomain: a name below it, such as www.example.com, app.example.com, or preview.example.com.
  • Staging hostname: the platform address used before the public connection.
  • Canonical origin: the one public scheme and hostname the site uses in links, metadata, cookies, and callbacks.

If both the apex and www should work, choose one canonical destination and redirect the other. Do not leave two independent copies serving indefinitely. The browser may appear happy, but links, cookies, analytics, and search signals can split between them.

Record the website release or snapshot being connected too. A perfect DNS change that points to the wrong project is still a failed launch.

Separate domain, DNS, and website ownership

The company that registered the domain may not be the company currently hosting its DNS. Cloudflare's DNS concepts documentation distinguishes the registrar, which reserves the name, from authoritative nameservers, which hold the definitive records.

Before asking anyone to log in, identify four owners:

  1. Registrant or domain owner: the client entity that should retain the name.
  2. Registrar account owner: the person responsible for renewal and registration settings.
  3. Authoritative DNS administrator: the account that can publish the required records.
  4. Website platform owner: the account that can add and verify the hostname.

One person may fill several roles, but the roles should still be written separately. I would keep the domain in a client-controlled account and grant the agency the narrow access needed for the work. Moving every client domain into one agency account may feel convenient, but it creates a difficult exit and a concentrated renewal risk.

Do not place passwords, recovery codes, verification tokens, or secret values in the project worksheet. Record the owner and approved access path instead.

Inventory DNS before making the route change

Open the authoritative DNS dashboard and capture the before state. The goal is not to become a DNS archaeologist. It is to know which records serve the website and which records support something else.

Common record types can share one zone while doing very different jobs. Cloudflare's record-type reference explains that A and AAAA records map a name to IPv4 and IPv6 addresses, a CNAME maps one name to another name, TXT records can prove ownership, MX records route mail, and CAA records limit which certificate authorities may issue certificates.

Record or settingLikely roleAgency action
A, AAAA, or CNAME at the chosen web hostnameExisting website routeCompare with the platform's requested route and replace only an actual conflict
MXEmail deliveryPreserve unless the email owner explicitly approves a mail change
TXTOwnership, SPF, or another serviceIdentify its purpose before editing or removing it
DKIM or DMARC-related recordEmail authentication and policyPreserve unless the mail project is separately in scope
CAACertificate authority policyReview only if certificate provisioning reports a relevant error
NameserversDelegation to authoritative DNSDo not change merely to connect one website unless the chosen setup explicitly requires a DNS migration

Capture what exists, when it was captured, and where the evidence is stored. Then identify records at the exact hostname being connected. A CNAME for shop.example.com does not conflict with a new record for www.example.com.

Route with the records shown by the website platform

On Fork, the current custom-domain documentation describes three steps: add the exact hostname in the space or organization domain controls, publish the ownership-verification and route records shown by Fork, then verify. Fork checks ownership, activates routing, and obtains a TLS certificate.

The important phrase is shown by Fork. I would not copy an IP address, CNAME target, or TXT token from this article, a previous project, or a registrar tutorial. Those sources can explain the fields, but the current setup screen is authoritative for this connection.

  1. Add the exact chosen hostname to the correct website project or space.
  2. Keep the platform screen open and copy each record into the authoritative DNS dashboard.
  3. Match type, host or name, target or value, and any required proxy setting exactly.
  4. Leave the DNS provider's default TTL unless the platform gives a different instruction.
  5. Save, then compare the saved records character for character with the platform screen.

DNS providers label the same fields differently. “Name,” “Host,” and “Hostname” may refer to the record name. “Value,” “Target,” “Content,” and “Points to” may refer to the destination. Some dashboards expect @ for the apex. Some expect a blank field or the full domain. For a subdomain, one provider may expect www while another accepts www.example.com.

That is why I would inspect the provider's preview of the final fully qualified name before saving. A doubled entry such as www.example.com.example.com can look plausible in a form while being useless in public DNS.

Handle a DNS proxy deliberately

If the client uses Cloudflare, an A, AAAA, or CNAME record may have a proxy toggle. Proxied means web traffic passes through Cloudflare; DNS-only returns the route without that HTTP proxy. Cloudflare's proxy-status documentation says ownership-verification CNAME records should not be proxied.

Do not turn every record gray or orange from a generic rule. A verification record and a web-traffic record can have different requirements. Follow the current Fork setup instruction for each record. If Fork reports that verification cannot see the expected value, compare the public answer with the requested record and check whether a proxy is masking it.

Changing nameservers is a larger operation than adding one record. It moves authority for the whole DNS zone and can affect web, mail, and service verification. I would only do that when the selected setup explicitly requires a DNS-provider migration and the complete zone has been reviewed.

Prove ownership, routing, and TLS separately

A custom-domain status usually passes through several states. Fork's documentation makes the sequence explicit: domain records move through verification and certificate provisioning before becoming active. A DNS record can therefore be correct while HTTPS is not ready, or ownership can be verified while the route still points somewhere else.

I would record separate evidence for four checks:

  1. Ownership: the platform reports that the verification record is accepted.
  2. Route: public DNS for the exact hostname returns the intended platform route.
  3. TLS: the live hostname presents a valid certificate that covers that hostname.
  4. Application: the hostname serves the correct website release and critical paths work.

Do not repeatedly rewrite a correct record while caches and certificate provisioning are still catching up. Note the time, status, and exact error. If ownership passes but certificate provisioning reports a CAA problem, investigate that specific condition. Let's Encrypt's CAA documentation explains that CAA can restrict which certificate authorities are allowed to issue for a domain. Fork's public docs do not name a universal CAA value, so guessing one would be worse than escalating the recorded status.

Test the live origin, not just the dashboard

Once the platform reports the domain active, open a fresh browser session at the canonical HTTPS URL. Confirm the expected page, title, navigation, and release. Then test the alternate hostname behavior.

A practical acceptance pass includes:

  • the apex and www behavior that the connection brief promised;
  • a valid HTTPS connection without a certificate warning;
  • representative deep links and one invalid path;
  • the primary navigation at phone and desktop widths;
  • business-critical forms followed through to their approved destination;
  • canonical tags, social metadata, sitemap URLs, and generated application links;
  • analytics in the intended production property, if analytics is in scope;
  • OAuth callbacks, cookies, webhooks, and external return URLs for an application that uses them.

Fork recommends one canonical application origin because OAuth callbacks, cookies, and application-generated links need to use the hostname visitors actually visit. The custom hostname routes to the same live Fork space and follows its access policy, but that does not automatically rewrite every origin stored in application configuration.

A successful homepage request is useful evidence for one request. It does not prove that a contact form reaches the client, that an OAuth callback is allowed, or that every internal link uses the new origin.

Worked example: connect a five-page brochure site

Consider an illustrative project for a fictional landscape architecture studio. Assume the client already owns northbank.example, email is active on that domain, the new five-page site is approved in Fork, and the site has one contact form. The site has never been public at this domain, so this is a connection, not a search migration. These are planning assumptions, not a customer result.

StageAgency actionEvidenceStatus after first pass
NameChoose https://www.northbank.example as canonical and redirect the apexBrief names the Fork space, approved snapshot, both hostnames, and approversPass
RouteInventory DNS, preserve MX and mail-authentication records, then add the exact Fork verification and route recordsBefore screenshot and copy-exact record tablePass
ProveVerify ownership, route, certificate, apex redirect, pages, and form deliveryFork status, browser check, redirect result, labeled form recordHold: canonical tag still uses the staging hostname
OperateRecord client registrar owner, DNS admins, platform owner, support route, and rollback ownerCompleted handoff sectionPass

The domain is not accepted yet. The DNS work passed, but the public origin is inconsistent inside the site. The team updates the canonical tag, checks all five pages, and repeats the discovery portion of the production pass. Only then does the connection record move from hold to ship.

Notice what the agency did not change: MX, SPF, DKIM, registrar ownership, nameservers, page design, and content. A narrow domain connection stayed narrow.

Add a migration branch when public URLs change

If the client is moving an established public site from one hostname to another, DNS setup is only part of the work. Create a URL map from each important old URL to its relevant new destination. Update internal links, canonicals, sitemap entries, and any origin-dependent configuration.

Google's site-move guidance recommends server-side permanent redirects where possible, testing the redirects, updating canonicals and internal links, submitting the new sitemap, and monitoring both locations. It also recommends changing one major thing at a time where practical. I would avoid combining a domain move, CMS replacement, and complete redesign into one unobservable event.

The Search Console Change of Address tool is relevant to an actual domain or subdomain move. Google's guidance says it is not required merely for HTTP to HTTPS or switching between www and non-www on the same domain.

Keep old-to-new redirects direct and relevant. Sending every former service page to the new homepage creates a poor visitor path and weak evidence that the migration was mapped carefully.

Troubleshoot from the stage that failed

“The domain is broken” is not a diagnostic. Start with the last stage that passed.

Observed stateCheck nextAvoid
Platform cannot verify ownershipAuthoritative nameservers, exact TXT or CNAME host and value, duplicated domain suffix, proxy settingAdding several alternative verification records at once
Ownership passes, route failsExact web hostname, conflicting A/AAAA/CNAME records, saved target, public DNS answerDeleting unrelated TXT or mail records
Route passes, certificate is pendingRecorded platform status, time of change, conflicting route, relevant CAA or DNS errorGuessing a certificate authority or repeatedly changing correct DNS
HTTPS loads the wrong siteHostname attached to the correct project and release, canonical host configurationCalling the connection complete because DNS resolves
Homepage works, app flow failsCookie domain, OAuth callback, webhook allowlist, form destination, generated linksTreating one page load as end-to-end proof
Email fails after launchCompare current MX and mail-authentication records with the before inventoryMaking more website-route changes before identifying the mail difference

Keep each correction observable. Change one identified cause, wait for the relevant state, and repeat the affected check. That creates evidence instead of a pile of coincidental changes.

Operate the domain after it connects

A domain can work today and still be fragile. Finish by recording who renews the registration, who can change DNS, who owns the website platform account, who approves origin changes, and who responds to a certificate or routing alert.

Remove temporary access that is no longer needed. Keep a dated connection record with the selected hostname, before-state inventory, platform record set, acceptance evidence, and rollback action. Store only non-sensitive evidence.

If the client will manage ordinary site updates, continue with the website handoff checklist. Domain administration should not be bundled casually with content editing. Someone who can update a paragraph does not automatically need authority over nameservers, renewals, or OAuth origins.

Schedule a post-launch check based on the project's risk. Reopen the domain record after a DNS-provider move, registrar transfer, canonical-origin change, major authentication change, or certificate-specific incident.

Download the custom domain connection worksheet

I turned the Name, Route, Prove, Operate framework into a downloadable custom domain connection worksheet. It includes the connection brief, ownership map, before-state DNS inventory, copy-exact record table, verification log, live acceptance tests, migration branch, rollback plan, and handoff record.

Use it as a project record, not as a source of DNS values. The exact records still come from the current website platform's domain controls.

Common custom domain questions

Should the agency own the client's domain?

I would keep the domain registered to and controlled by the client, then grant the agency the access required to operate it. If the agency buys a domain during a project, document transfer and renewal responsibility before launch rather than leaving ownership implicit.

Do I edit DNS where the domain was purchased?

Not necessarily. The registrar and authoritative DNS provider can be different companies. Identify the authoritative nameservers and make the record change in the service that holds the definitive zone.

Should I delete the old records first?

Remove or replace only a record that truly conflicts at the exact hostname and purpose in scope. Preserve mail and unrelated verification records. For a live migration, plan the cutover and rollback before removing the existing web route.

How long should I tell the client the change will take?

Give the client a change window and status checkpoints, not a universal propagation promise. DNS caching, provider behavior, verification, and certificate provisioning are separate variables. Report the actual platform state and time of each check.

Is the job done when HTTPS works?

No. HTTPS proves a secure connection to a host that presented a valid certificate. You still need to confirm the intended release, redirects, links, forms, canonical metadata, callbacks, cookies, analytics, and handoff responsibilities that apply to the project.

Make the connection a client deliverable

I want a domain connection record to answer four questions without a detective story: What exact name did we choose? What exact route did we change? What proved the live site works? Who operates it next?

That turns a fragile DNS favor into a bounded agency deliverable. The client keeps ownership, the agency preserves unrelated services, the website gets one canonical origin, and acceptance rests on the live business journey rather than a green status badge.

Fork is built for client websites with AI access, including managed custom-domain verification and TLS for a live space. If that operating model fits the service you want to offer, join the Fork waitlist and use the worksheet to define your next domain connection while access opens in batches.

Written by Chris Peterson. Sources checked 2026-11-04.