HTTPS errors usually point to a small set of certificate, hostname, trust, protocol, or deployment problems. This reusable checklist explains how to identify the failure, verify it in a browser and with OpenSSL, and safely renew or redeploy a certificate without guessing.
Overview
An SSL certificate is used to authenticate a website and help establish an encrypted TLS connection. Although people commonly say “SSL certificate,” modern web connections generally use TLS. A browser may reject HTTPS when the certificate is expired, issued for a different hostname, incomplete, signed by an untrusted authority, or presented by the wrong server.
Start by recording the exact hostname and the complete browser error. Test https://example.com separately from https://www.example.com, because each hostname must be covered by the certificate and correctly routed by DNS and the web server. Also test from an affected device and, if possible, a second network. This helps distinguish a server-side problem from a local trust store, proxy, or DNS issue.
A useful diagnosis sequence is:
- Confirm the hostname in the address bar and the certificate’s names.
- Check the certificate’s validity dates and issuer.
- Inspect whether the server sends the required intermediate certificates.
- Verify DNS, virtual-host routing, and SNI configuration.
- Check TLS protocol and cipher compatibility if the handshake fails before a certificate is shown.
- After HTTPS works, inspect redirects and page resources for mixed content.
For server configuration context, compare the relevant deployment model in this guide to Nginx, Apache, and Caddy. The commands and filenames differ, but the certificate checks are broadly the same.
Checklist by scenario
Hostname mismatch
Typical messages include “certificate is not valid for this website” or “common name mismatch.” Inspect the certificate’s Subject Alternative Name (SAN) entries and compare them with the exact hostname being requested. A certificate for example.com does not automatically cover www.example.com, and a certificate for one subdomain does not generally cover another. Wildcard coverage also has defined boundaries; a wildcard for *.example.com is not a general substitute for the apex domain or deeper subdomains.
- Confirm that DNS points the hostname to the intended server or load balancer.
- Request or select a certificate containing every required hostname.
- Check both IPv4 and IPv6 records if users receive different results.
- Verify that the correct certificate is bound to the HTTPS listener.
Expired or not-yet-valid certificate
Check the certificate’s “not before” and “not after” dates, along with the clock on the client and server. An incorrect system clock can make a valid certificate appear premature or expired. If the certificate really is outside its validity period, renew it through the certificate authority or ACME client, then install the new certificate and private key on every TLS termination point.
Do not assume that renewing a certificate automatically deploys it. A reverse proxy, CDN, ingress controller, or load balancer may continue serving the previous certificate until its configuration is updated or the service is reloaded.
Incomplete certificate chain
An “incomplete chain” error often means the server sent its leaf certificate but omitted one or more intermediate certificates. Browsers with a cached intermediate may succeed while new devices, command-line clients, or monitoring systems fail. Install the server certificate together with the CA-provided intermediate chain as the service requires; do not replace the chain with a private root certificate.
Use the provider’s documented full-chain file when one is supplied. The exact file order and configuration directive vary by server, so confirm the instructions for your deployment rather than copying settings between Nginx, Apache, containers, and managed platforms.
Untrusted issuer or root
If the issuer is not trusted by the client, determine whether the connection uses a private certificate authority, an outdated trust store, or an incorrectly installed public chain. Internal services may intentionally use a private CA, but every approved client then needs the organization’s trust configuration. For a public website, confirm that the certificate was issued by the intended authority and that the server is not presenting a test or staging certificate.
SNI or virtual-host problem
Multiple HTTPS sites can share an IP address when the client indicates the requested hostname using Server Name Indication (SNI). If the server returns a default certificate for another site, inspect the HTTPS virtual-host or listener mapping. Confirm that the hostname is configured in the correct site block, the certificate is attached to that block, and the request reaches the expected proxy or load balancer.
TLS protocol or handshake failure
Some failures occur before certificate validation. Review the server’s enabled TLS versions and the client’s supported versions, then check recent configuration changes, termination proxies, and legacy integrations. Avoid weakening the configuration simply to make one old client connect. Instead, identify the incompatible client and decide whether it can be updated or isolated. A successful certificate inspection does not prove that every client can complete the TLS handshake.
Mixed content after HTTPS is fixed
Mixed content occurs when an HTTPS page requests resources over plain HTTP. The certificate may be valid while scripts, images, fonts, or API calls are blocked or warned about. Use the browser’s developer tools and security console to identify the exact URL, then update application configuration, asset URLs, API endpoints, and canonical redirects. This is separate from a certificate error, but it often appears during the same migration.
How to verify the certificate
Browser checks are a useful first pass. Open the site, select the lock or site-information control, view the certificate, and record the subject names, issuer, dates, and chain. Repeat the check for each hostname and follow redirects. Private browsing or a second browser can help reveal cached behavior, but neither replaces a server-side check.
From a terminal, inspect the certificate presented for a hostname:
openssl s_client -connect example.com:443 -servername example.com -showcerts
The -servername option matters when the server uses SNI. Look for the leaf certificate, intermediate certificates, validity dates, SAN entries, and the verification result. To print the leaf certificate in a more readable form, one commonly used pattern is:
openssl s_client -connect example.com:443 -servername example.com </dev/null 2>/dev/null | openssl x509 -noout -subject -issuer -dates -ext subjectAltName
For a deeper check, use a browser-based TLS inspection service or your organization’s monitoring tool, but treat its result as a view of a particular network path and configuration. Test after every deployment change and from more than one client type when the incident affects only some users.
What to double-check before renewal or deployment
- Inventory: List every hostname, certificate, private key, issuer, expiration date, and termination point.
- Ownership: Confirm who controls DNS and who can complete the chosen domain-validation method.
- ACME configuration: Check the account, challenge type, permissions, renewal hook, and storage location. Run a supported staging or dry-run procedure where available.
- Private key handling: Protect the key, restrict access, and avoid placing it in source control, public logs, or chat messages.
- Chain selection: Install the chain intended for the server and client population. Do not mix certificates, keys, and intermediates from different issuance attempts.
- Deployment coverage: Update origin servers, containers, ingress controllers, CDNs, load balancers, and disaster-recovery environments as applicable.
- Reload behavior: Confirm that the service actually reloaded the new files and that old workers are not still serving the previous certificate.
- Rollback: Keep a controlled rollback plan, but remove obsolete keys and certificates according to your security procedures once the change is verified.
After deployment, test the apex domain, common subdomains, redirects, API endpoints, health checks, and any client applications that do not use a standard browser. If the site also changed its frontend or backend behavior, separate certificate checks from application checks; for example, a CORS failure is a header or request-policy problem rather than proof that TLS is broken. See the CORS troubleshooting guide when browser requests fail after HTTPS is restored.
Common mistakes
- Checking only the homepage while an API, asset host, or admin subdomain still has an expired certificate.
- Renewing the certificate but forgetting to reload the proxy or listener that serves it.
- Installing only the leaf certificate and omitting the intermediate chain.
- Testing through a CDN while the origin has a different certificate or TLS policy.
- Debugging cached DNS or browser state without testing the actual server response.
- Disabling certificate verification in application code as a permanent workaround.
- Assuming a valid certificate eliminates mixed content, redirect loops, or API authentication problems.
- Allowing renewal credentials or private keys to appear in deployment logs.
When to revisit
Revisit this checklist before a certificate’s renewal window, a domain launch, DNS migration, load-balancer change, CDN cutover, web-server replacement, or major operating-system and runtime update. Review it after changing ACME clients, certificate authorities, trust-store packages, TLS policies, or browser-support requirements. It is also worth scheduling a periodic inventory review so certificates are tracked by hostname and deployment location rather than by one person’s memory.
For the next incident, save the exact hostname, timestamp, client, network, browser message, certificate subject, issuer, dates, and OpenSSL output. Compare those details with the last known-good deployment. That small record turns a vague “HTTPS is broken” report into a repeatable investigation and gives the next renewal a clear, testable runbook.