For years, certificate expiry was an annual chore. Somebody had a calendar reminder, somebody else had the access to the portal, and every so often the reminder was missed and a service went down.
That model has an end date. The maximum lifetime of publicly trusted TLS certificates is shrinking on a published schedule, and it ends at a number small enough that manual renewal stops being a viable process.
The timeline
The CA/Browser Forum, the body that sets the baseline rules for publicly trusted certificate authorities, approved ballot SC-081 in 2025. It reduces the maximum validity in steps:
| Certificates issued from |
Maximum validity |
| Before 15 March 2026 |
398 days |
| 15 March 2026 |
200 days |
| 15 March 2027 |
100 days |
| 15 March 2029 |
47 days |
The period during which a validated domain control result can be reused also shrinks, down to a matter of days by the end of the schedule. In practice, that means a CA re-checks that you control the domain at nearly every issuance.
If you are reading this in late 2026, we are in the 200-day phase. It is the comfortable one. The step to 100 days is when processes that survived on discipline start to fail.
An important boundary: these rules apply to publicly trusted certificates. A private CA used inside your organization is not bound by them, although its own lifetimes are worth shortening for the same reasons.
What actually breaks
The certificate itself is rarely the problem. The problems are around it:
- Certificates copied by hand into a key vault, a load balancer, an appliance or a config file.
- Services that only read the certificate at startup, so a renewed file on disk changes nothing until the next restart.
- Pinned leaf certificates in clients, which turn every renewal into a breaking change.
- Systems with no ACME support, such as old appliances or vendor-managed endpoints.
The inventory exercise alone is valuable. Many organizations discover certificates nobody remembers owning.
Automate with ACME
ACME, defined in RFC 8555, is the protocol that lets a client request, validate and renew certificates without a human in the loop. The two common validation types matter operationally:
- HTTP-01 proves control by serving a file on port 80. Simple, but it cannot issue wildcards and needs the endpoint to be reachable.
- DNS-01 proves control by publishing a TXT record. It works for wildcards and for internal services, but it needs DNS write access.
That access is a risk in itself. A common mitigation is to delegate _acme-challenge with a CNAME to a zone dedicated to validation, so the automation can only modify that one place.
Also worth knowing: the ACME Renewal Information (ARI) extension lets a CA tell clients when to renew, which is how CAs can ask for early replacement during a mass revocation.
Inventory before automation
You cannot automate what you cannot find. Start by building a list of every certificate your organization actually serves, from three directions:
- Certificate Transparency logs. Every publicly trusted certificate is logged. Searching the logs for your domains reveals certificates that somebody issued, including ones nobody in your team remembers requesting.
- Your own scans. Walk your IP ranges and DNS names, connect on the common TLS ports, and record what is served.
- Your CAs and cloud accounts. Export what has been issued, and by whom.
Compare the three. The differences are the interesting part.
The ones that cannot do ACME
Some endpoints will never run an ACME client: appliances, vendor-managed services, embedded devices. There are still ways to remove the human.
- Put a reverse proxy or load balancer that does support automation in front, and terminate TLS there.
- Use a managed certificate from the platform when it exists, which renews without any action on your side.
- Where a vendor requires you to upload a certificate, script the upload against their API and run it from the same automation that renews the certificate.
What remains after that is a short, explicit list of exceptions. Keep it visible, give each item an owner, and treat each as technical debt with a date.
Client certificates and internal PKI
Public certificates are only part of the picture. Many organizations also use client certificates for mTLS between services and from devices. These come from an internal CA, outside the CA/Browser Forum rules, and they have the same problem: lifetimes measured in years, and renewal by hand.
The shorter timelines are a good prompt to fix them as well. Short-lived internal certificates, issued automatically to workloads, remove the reasons to keep long-lived ones.
Rate limits
ACME authorities enforce rate limits, typically per registered domain and per time window. Shorter lifetimes mean more issuance, and an estate with hundreds of subdomains can hit them without anything being wrong. Consolidate names where it makes sense, use a wildcard for the cases that need one, and test the automation against the CA's staging environment, which has more generous limits, before pointing it at production.
Rehearse the failure
Once renewal is automated, the failure that matters is the one where the automation silently stops: a changed DNS credential, a renamed API, a rate limit. Run a game day: break the renewal on a non-critical service and see how long it takes for someone to notice. If the answer is "when it expires", the monitoring is not finished.
Monitoring changes shape
An alert at "14 days before expiry" made sense for a one-year certificate. For a 47-day one, it means the certificate is already in the last third of its life.
Better to define alerts relative to the lifetime. Renew automatically at around two thirds of the validity, and alert if a certificate is still not renewed well past that point, because that means the automation is broken, not that a reminder is due.
csharp
using var client = new TcpClient(host, 443);
using var ssl = new SslStream(client.GetStream(), false, (_, _, _, _) => true);
await ssl.AuthenticateAsClientAsync(host);
var cert = new X509Certificate2(ssl.RemoteCertificate!);
var lifetime = (cert.NotAfter - cert.NotBefore).TotalDays;
var remaining = (cert.NotAfter - DateTime.UtcNow).TotalDays;
var fractionLeft = remaining / lifetime; // alert when this drops under ~0.33
The validation callback above accepts any certificate on purpose, because the goal is to read the expiry of whatever is being served, not to trust it. Do not reuse it for real connections.
Monitor what is served, not what is stored. A renewed certificate sitting in a vault does nothing if the process serving traffic never reloaded it.
Conclusion
When something happens once a year, it can be a calendar entry. When it happens every six weeks, it is either automated or it becomes an incident, and there is no stable middle ground.
The real change is not a number in a standard. It is that certificate renewal moves from an event that people perform to a property of the system that people verify.
References