DNS and SSL Troubleshooting Workflow: Check Records, Propagation, Certificates, and HTTPS Redirects
dnsssltlshttpsdomainsweb-hostingdevops

DNS and SSL Troubleshooting Workflow: Check Records, Propagation, Certificates, and HTTPS Redirects

CCode Craft Hub Editorial Team
2026-11-17
8 min read

A practical DNS and SSL troubleshooting checklist for records, propagation, certificates, SNI, HTTPS redirects, and mixed content.

When a domain fails to load, several different systems may be responsible: DNS may point to the wrong server, a change may not yet appear through recursive resolvers, the TLS certificate may not cover the requested hostname, or an HTTPS redirect may be misconfigured. This reusable DNS and SSL troubleshooting workflow helps you check each layer in order, isolate the failing component, and verify the fix without guessing.

Overview

Domain and HTTPS problems are easier to solve when you separate name resolution, network reachability, certificate negotiation, and application redirects. A browser compresses all of these steps into one visible error, but each layer can be tested independently.

  1. DNS: Does the hostname resolve to the intended address, and are the authoritative nameservers serving the expected records?
  2. Connectivity: Does the resolved address accept traffic on the required ports, usually 80 and 443?
  3. TLS: Does the server present a valid certificate for the hostname, with an acceptable validity period and trust chain?
  4. HTTP: Does the server return the intended status code, redirect to the correct URL, and load page resources without mixed-content errors?

Record the hostname, expected destination, DNS provider, hosting platform, and recent changes before testing. This prevents a common diagnostic error: checking one subdomain while the application, certificate, or DNS record belongs to another. For deployments involving containers or reverse proxies, also compare this workflow with the Docker Compose troubleshooting guide to check service-level networking and startup issues.

DNS record reference

RecordPurposeWhat to verify
AMaps a hostname to an IPv4 addressAddress matches the intended service and has no stale duplicate
AAAAMaps a hostname to an IPv6 addressIPv6 endpoint is configured correctly; remove or fix it if unreachable
CNAMEAliases one hostname to anotherTarget is correct and does not create an invalid or unintended chain
NSIdentifies authoritative nameserversRegistrar delegation matches the DNS provider in use
TXTStores verification and policy textValue is complete, correctly quoted by the provider, and attached to the right name
CAACan restrict which certificate authorities issue certificatesCertificate issuance is compatible with the published policy

Checklist by scenario

The domain does not resolve

  1. Confirm the spelling and whether the failing name is the apex domain, such as example.com, or a subdomain, such as www.example.com.
  2. Check the domain’s delegated nameservers. Use dig NS example.com or an equivalent DNS lookup tool, then compare the result with the nameservers configured at the registrar.
  3. Query the authoritative nameserver directly. First identify it, then run a command such as dig @ns1.example-dns.com example.com A. This distinguishes a missing record from delayed results in a recursive resolver.
  4. Check both A and AAAA records. A correct IPv4 address does not guarantee that an incorrect IPv6 address will be ignored by every client.
  5. Review the DNS zone for conflicting records, an accidental wildcard, an incorrect CNAME target, or a record created at the wrong level.

If the authoritative response is correct but public resolvers show an older value, the difference may be related to TTL and resolver caching. A propagation checker can provide useful comparison points, but treat it as a set of observations rather than proof that every resolver has updated.

The domain resolves to the wrong service

  1. Compare the returned address with the hosting or load-balancer address documented by your provider.
  2. Check for both apex and www records. They may intentionally point to different services, but they should not do so accidentally.
  3. Inspect the redirect destination with curl -I http://example.com and curl -I https://example.com. Follow the complete chain with curl -IL https://example.com.
  4. Review proxy, CDN, load-balancer, and origin settings. A correct DNS record can still reach a default virtual host if the hostname is not configured at the next layer.

The browser reports a certificate warning

  1. Inspect the certificate’s subject names and confirm that the requested hostname is covered. The apex domain and a subdomain are separate names unless both are included.
  2. Check the certificate’s validity period and the server or client clock.
  3. Test the certificate presented for the exact hostname using SNI: openssl s_client -connect example.com:443 -servername example.com. Look for the presented subject, subject alternative names, and verification output.
  4. Check whether a reverse proxy or CDN presents a different certificate from the origin server.
  5. Confirm that the server sends the required intermediate certificates. A certificate can appear valid on one device and fail elsewhere when the served chain is incomplete.
  6. If issuance or renewal fails, review DNS validation records, HTTP validation paths, certificate authority restrictions, and the account or automation logs used by the ACME client.

For token and API-related checks after HTTPS is working, the JWT decoder and validator guide can help separate transport security problems from authentication and claim errors.

HTTPS redirects loop or point to the wrong URL

  1. Capture every response in the chain with curl -IL, including the status code and Location header.
  2. Look for alternating HTTP and HTTPS destinations, changes between apex and www, or redirects between two canonical paths.
  3. Check proxy awareness. If TLS terminates at a load balancer, the application must receive accurate forwarded-protocol information; otherwise it may believe every request arrived over HTTP and redirect repeatedly.
  4. Choose one canonical HTTPS hostname and configure the other variants to redirect to it deliberately.

The page loads but shows mixed-content errors

Open the browser’s developer tools and inspect the Console and Network panels. Identify scripts, stylesheets, images, fonts, or API calls requested over http:// from an HTTPS page. Update absolute URLs, environment variables, content-management settings, and third-party integrations. Relative URLs and protocol-independent assumptions should be reviewed carefully rather than changed blindly. The Browser DevTools performance workflow includes a broader method for inspecting requests and verifying frontend changes.

What to double-check

  • Nameserver authority: Editing records at a DNS dashboard has no effect if the registrar delegates the domain to different nameservers.
  • TTL expectations: Lowering a TTL does not instantly remove values already cached under a previous TTL. Plan changes before the migration rather than after a problem appears.
  • Record scope: A record for the apex does not automatically configure every subdomain. Check the exact hostname used by the browser, API client, webhook, or email service.
  • IPv6 behavior: An AAAA record can send some users to an endpoint that is not listening or is blocked by a firewall.
  • SNI: Shared hosting and reverse proxies use the requested hostname to select a certificate and virtual host. Always test with the real hostname, not only the IP address.
  • Certificate coverage: Verify every production hostname, including alternate domains used for redirects, APIs, assets, previews, and administrative endpoints.
  • Renewal automation: Confirm that renewal runs before expiry, can complete its DNS or HTTP challenge, and reloads the web server or proxy after replacing the certificate.
  • Application configuration: A valid certificate does not fix an incorrect base URL, origin policy, cookie setting, API endpoint, or redirect rule.

Use a small evidence log during the investigation: timestamp, command, hostname, resolver, returned address, certificate expiration, HTTP status, and next action. This is especially useful when results differ between a local network, a company resolver, and a public recursive resolver.

Common mistakes

Changing several layers at once. Replacing DNS records, proxy settings, and redirect rules together makes the result difficult to interpret. Change one layer, test it, and keep the rollback value.

Assuming propagation explains everything. Cached DNS data can explain inconsistent answers, but it cannot explain a certificate-name mismatch or a redirect loop. Query the authoritative server and test the TLS and HTTP layers separately.

Testing only one hostname. The site may work at www while the apex fails, or the website may work while an API subdomain has no certificate. Build the hostname list from actual links, environment variables, and deployment configuration.

Checking a certificate by IP address. IP-based testing may select a default certificate and virtual host. Use the hostname and SNI whenever possible.

Ignoring the origin behind a proxy. A CDN can serve a correct edge certificate while the origin has a separate problem. Test each layer according to the provider’s architecture and avoid exposing an origin unnecessarily just to diagnose it.

Publishing sensitive data to online utilities. Online developer tools are convenient for inspecting public DNS responses and non-sensitive configuration. Do not paste private keys, access tokens, internal hostnames, or confidential certificates into third-party tools. Local commands are preferable for private diagnostics.

When to revisit

Run this checklist before a domain migration, nameserver change, new subdomain launch, hosting move, reverse-proxy change, or certificate renewal. Repeat it after deployment and after any change to DNS, firewall rules, load balancing, CDN configuration, or canonical URL settings.

It is also worth scheduling a periodic review of renewal automation and DNS ownership records. Interfaces and certificate workflows change over time, and an account, validation method, or provider configuration that worked during launch may not match the current deployment. Recheck command syntax and provider-specific instructions when tools or workflows change.

Final launch checklist

  • Registrar nameservers match the intended authoritative DNS provider.
  • A, AAAA, and CNAME records return the expected values for every production hostname.
  • Authoritative and recursive DNS responses have been compared where timing matters.
  • Ports 80 and 443 reach the intended proxy or server.
  • The certificate covers each hostname, is within its validity period, and presents the expected chain through SNI.
  • HTTP redirects produce one deliberate HTTPS destination without loops.
  • Browser tools show no blocked mixed-content requests or incorrect API URLs.
  • Certificate renewal, DNS validation, and service reloads have been tested or verified in the deployment workflow.

Work from the outside in: authoritative DNS, public resolution, connectivity, TLS, redirects, and finally page resources. That order turns a vague domain outage into a short list of testable conditions and gives you a repeatable record to use the next time the underlying setup changes.

Related Topics

#dns#ssl#tls#https#domains#web-hosting#devops
C

Code Craft Hub Editorial Team

Technical Editor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.