← All articles

How to Manage Certificate Expiration Risk Solo

Published · 10 min read

Key takeaways

  • Certificate expiration risk covers more than public TLS: code-signing certs, client/mTLS certs, and internal CA roots each fail differently and need their own inventory rows.
  • Alerting alone is not a control; pair external probes at 30, 14, and 3 days with a calendar deadline and a CI deploy gate that fails builds inside the renewal window.
  • With short-lived certificates, monitor the renewal pipeline itself, including ACME exit codes and last-success timestamps, because a silently broken client expires everything at once.
  • Score each certificate's blast radius on reach, substitutability, and customer visibility, and give anything scoring 12 or higher a runbook and a named on-call owner.
  • Write the expiration runbook before the cert expires, with verbatim verification commands, a rollback path, and escalation thresholds at T-7, T-2, and expiry.

You manage certificate expiration risk by treating every cert (TLS, code-signing, internal CA) as an asset with an owner, a renewal path, and a blast radius, then layering alerting fallbacks on top. Simple SSL alerts catch the obvious expirations; they miss the signing cert that bricks your Windows installers or the internal CA that takes down your whole fleet. This framework covers the full lifecycle in seven steps.

How do you manage certificate expiration risk?

You manage certificate expiration risk with four controls: a complete inventory, named ownership, automated renewal, and planning for the failure modes when renewal silently breaks. Alerting alone is not a control. An expiration alert fires at 3 AM, you are mid-incident, and the renewal pipeline that was supposed to handle it failed weeks earlier. Most teams either monitor too little (just the TLS cert on the homepage) or find out from customers instead of probes.

The four controls: inventory, ownership, automation, failure modes

Inventory means knowing every certificate: public TLS, code-signing, and anything your internal CA issued. Ownership means one person is accountable for each cert renewing, even on a team of one. Automation means renewal runs without a human, and you verify it ran. Failure-mode planning means asking what happens when the ACME renewal fails, the email goes to a departed contractor's inbox, or the alert fires during an outage. The trend is working against manual renewal: the CA/Browser Forum has voted to shorten maximum certificate lifetimes toward 47 days (CA/Browser Forum ballot SC-081), which multiplies your renewal count and your exposure to one missed cycle. We cover the alerting side in more depth in our four-alert strategy for certificate expiration, but alerts are the last line, not the framework.

What does certificate expiration risk actually include beyond SSL/TLS?

Most teams only track public TLS certs, then get surprised when something else expires. Your certificate risk surface is bigger, and each class fails differently.

Certificate classWhat breaks when it expires
Public TLSBrowser warnings, API clients fail, app stores flag your app
Code-signingBuilds fail, installers show untrusted warnings, CI pipelines halt
Client/mTLSService-to-service auth dies, often with confusing 403s
Internal CA roots and intermediatesEvery cert signed below them fails at once
VPN and database certsRemote access drops, app-to-DB connections refuse TLS

Code-signing certificates: the silent build breaker

Code-signing certs sit outside your uptime monitoring, so nothing pings you before they lapse. When one expires mid-release, your CI pipeline fails and signed installers start throwing untrusted warnings. Because the failure appears in the build step, it reads as a pipeline bug, not a cert problem. Add signing certs to the same inventory and expiration checks as your TLS certs, using a checklist like our SSL certificate expiration checker.

Internal CA roots: the blast-radius king

An internal root CA expiring is the worst single-cert failure you can have: every certificate it signed, across every service, fails simultaneously. That is a full outage caused by one file nobody looked at in three years. Track root and intermediate expiry dates first, and renew intermediates well ahead of the root.

How do you build a complete certificate inventory when nobody knows where all certs live?

You find forgotten certificates by scanning from the outside, grepping from the inside, and checking the stores you did not provision yourself. Discovery is the hard part; the inventory schema is easy.

Discovery sources that find the certs your team forgot

Start with four passes. First, scan every public IP and hostname you own with a TLS scanner so you see what is actually being served, not what the wiki claims. Second, search Certificate Transparency logs for your domains, because CT records every publicly trusted cert issued for them, including ones a former contractor requested years ago. Third, grep your repos and IaC for cert files, PEM blocks, and ssl_certificate directives. Fourth, enumerate cloud certificate managers (ACM, Azure Key Vault, GCP Certificate Manager) and load balancer configs, since cloud-terminated TLS never shows up in a repo grep.

That outside-in scan matters more than people expect. Let's Encrypt issues certificates valid for 90 days by design, and its ACME documentation explains why short lifetimes push teams toward automation rather than manual tracking. If any part of your stack still renews by hand, your inventory is the only thing standing between you and a 3 AM outage, so run discovery on a schedule, not once. Pair the inventory with automated SSL certificate expiration alerts so a missed row still gets caught: automated SSL certificate expiration alerts: a developer's guide to preventing downtime.

The minimum fields every inventory row needs

Keep it boring: hostname or service, certificate type (TLS, code-signing, internal CA), issuer, expiry date, where the private key lives, the renewal method (ACME, manual, cloud-managed), the owner, and the blast radius note. A spreadsheet works at your size. An inventory you cannot update in five minutes is an inventory that goes stale before the next renewal.

Who should own certificate renewal, and how do you assign accountability?

Ownership rules for a 1-10 person team

Pick one of two models and write it down. Per-domain ownership works when each person already owns a service: whoever owns the API owns api.yourapp.com's certs. A single certs owner works better under five people, because one person can hold the whole inventory in their head and nothing falls through a handoff.

Either way, ownership means one named person per certificate, not a role like "engineering." If your only owner leaves, an unowned cert is how an expired SSL certificate ends up blocking customer logins (https://blog.statuspulse.ai/post/expired-ssl-certificate-risks-for-security-and-website-access).

Make the handoff mechanical: the inventory lists an owner and a backup per cert, offboarding includes transferring both, and renewal reminders go to a shared inbox as well as the individual. The backup owner is your fallback when the primary is on holiday during an expiration window.

When do expiration alerts fail, and what fallbacks catch them?

Expiration alerts fail in predictable ways. The probe target goes down, so the check that would have flagged the cert never runs. SNI mismatches make the probe test the wrong cert, or a wildcard on a different host answers instead. Non-HTTP services (SMTP, IMAP, database TLS) are invisible to HTTP-only checks. And alert fatigue: a 30-day email lands in a inbox you triage weekly, and suddenly the cert has 4 days left.

Why a single 30-day alert is not a strategy

One alert at one threshold assumes someone sees it, owns it, and acts. Solo founders know how that goes. Code-signing certs are worse: expired signing certificates cause Windows SmartScreen warnings and failed signature validation on binaries already shipped, a failure mode Microsoft documents for Authenticode signatures (Microsoft code-signing docs). You cannot renew your way out of an expired code-signing cert; timestamps are the only mitigation, and those need configuring before expiry.

Layered alerting: external probes plus calendar plus deploy gates

Run at least three layers:

  1. External protocol-level probes at 30, 14, and 3 days, checking the actual cert served per SNI, not just port 443 on a hostname. StatusPulse's SSL probes check certificate validity as part of each probe run, so expiration surfaces even when the endpoint is otherwise healthy.
  2. A calendar or ticket deadline at renewal time, owned by whoever holds renewal (section 4), so alert delivery failure does not equal missed renewal.
  3. A deploy or CI gate that fails builds when a referenced cert is inside the renewal window, catching certs no external probe can reach, like internal CA intermediates.

External probes catch what internal cron jobs miss; the deploy gate catches what probes cannot see.

How do short-lived certificates change your expiration risk strategy?

Short-lived certificates flip the problem. With 90-day Let's Encrypt certs and ACME automation, renewal stops being a calendar task and becomes a background process. That removes the human failure mode, but it introduces a new one: if your ACME client stops working, you find out 60 days later when everything expires at once.

Monitor the renewal pipeline, not the certificate

Checking that a cert is valid tells you nothing about whether renewal will succeed next week. Instead, alert on the signals that predict failure: renewal job exit codes, last-successful-renewal timestamps, and the gap between renewal attempts. A cert that renews every 60 days but silently failed last Tuesday is a bigger risk than one 30 days from expiry with a healthy pipeline.

Practically, that means three checks: the ACME client's logs and exit status, the age of the deployed certificate (alert if it exceeds your renewal interval), and a canary renewal against your staging endpoint. Protocol-level probes that verify the served certificate chain catch the case where renewal succeeded but deployment did not.

The trade-off is real: automation removes 11 of 12 renewals' worth of manual work, but concentrates all the risk in one pipeline. Treat that pipeline like any other critical path in your SaaS, with the same uptime monitoring and alerting you apply to your app itself.

What should a certificate expiration runbook contain before the cert expires?

A runbook is useless if you write it during the outage. Write it while calm, store it next to your inventory, and test it on a staging cert before you need it at 3 AM.

Pre-expiry checklist vs expiry-day actions

The pre-expiry checklist covers renewal: the exact command per cert type (for ACME-managed TLS, a certbot renew with a documented deploy hook, per the Certbot documentation), where the renewed cert gets deployed, and the verification step that proves it landed. Verification commands belong in the runbook verbatim, not from memory: openssl s_client -connect host:443 piped to openssl x509 -noout -dates for TLS, and the equivalent signature-check command for code-signing keys. Expiry-day actions are what you do if renewal failed: the rollback path (redeploy the previous cert from backup), the comms template (a status page incident draft with placeholder text for cause and ETA), and the escalation ladder. Define thresholds: no renewal confirmed at T-7 days pages the owner, at T-2 days it pages the backup, at expiry it triggers the incident process and a public status update.

How do you assess the blast radius of a single expiring certificate?

Blast radius answers one question: if this cert expires unnoticed, what breaks and who notices? A cert protecting one internal admin panel is a nuisance. A wildcard on your API gateway is an outage for every customer at once.

Score each cert: reach, substitutability, customer visibility

Give each certificate three scores from 1-3. Reach: how many services depend on it (a SAN cert covering api, app, and admin touches more than a single-host cert). Substitutability: can you swap in another cert in minutes, or is it pinned into clients, mobile apps, or partner integrations? Customer visibility: does expiration break something customers call directly, or something only your team uses?

Multiply the three scores. Anything 12+ gets a runbook, an on-call owner, and a fallback alert well before renewal. Low-scoring internal CA certs can wait for the quarterly review. Re-score whenever you issue or retire a cert, so the inventory stays honest instead of decaying into shelfware.

FAQ

How far in advance should you renew an SSL certificate?

Start renewal at 30 days out, with escalation checkpoints at 14 and 3 days. That window gives you room for a failed ACME attempt, a departed owner, or an outage eating the alert. Internal CA roots need more lead time: renew intermediates well ahead of the root, since one root expiry fails every cert beneath it at once.

What happens if a code-signing certificate expires?

Your CI pipeline fails mid-release, and signed installers start throwing untrusted warnings, including Windows SmartScreen prompts on binaries you already shipped. Because the failure surfaces in the build step, it reads as a pipeline bug rather than a cert problem. You cannot renew your way out of it; timestamping configured before expiry is the only mitigation.

Can uptime monitoring tools detect expiring certificates on non-HTTPS services?

Usually not. HTTP-only checks never see SMTP, IMAP, or database TLS, and even HTTPS probes can test the wrong cert when SNI mismatches or a wildcard on another host answers. Use protocol-level probes that verify the actual certificate served per SNI, and add a CI gate that fails builds when referenced certs enter the renewal window.

Is a free certificate authority like Let's Encrypt riskier than a paid one?

The CA is not the risk; the renewal pipeline is. Let's Encrypt issues 90-day certificates by design, which pushes you toward ACME automation. That removes the human failure mode but concentrates risk in one pipeline: if your ACME client silently breaks, everything expires at once 60 days later. Monitor renewal job exit codes and last-success timestamps, not just the certificate.

Monitor it, then tell your customers

10 probes, 3 status pages, forever. No credit card.