You have probably been bitten at least once by an expiry nobody saw coming. A certificate lapses on a Sunday, an API key stops working during a demo, a build image ages out of support. This walkthrough shows how to set up a maintenance calendar for certificates, dependencies and logs in an afternoon, then keep it running with a few minutes of effort each week. Grab a coffee, open a blank document and follow along; every step is small on purpose.
Step 1: Make a register of everything that can expire
Start with a plain table. One row per item, four columns: what it is, where it lives, when it expires or goes stale, and who looks after it. Typical rows include TLS certificates for each domain, signing keys, cloud access tokens, container base images, language runtimes and any paid licence your build relies on. Do not worry about completeness. If you find a dozen entries in the first hour, you are ahead of most teams.
A tip from experience: ask the people who were around longest, “What has expired on us before?” Their answers produce the rows you would never find by scanning configuration alone.
Step 2: Sort the register by date and by pain
Add a column called “pain if missed” with three levels: low, medium, high. A forgotten internal tool token is low. A public certificate is high. Sorting by date first and pain second gives you an instant picture of what needs attention this month. Most registers show two or three high-pain items due sooner than anyone expected, and fixing those alone repays the effort.
Step 3: Pick the rhythm
Here is a simple starting pattern that suits many small and mid-sized teams:
- Weekly, fifteen minutes: scan the register for anything expiring within the next two months and ticket it.
- Monthly, one hour: apply patch-level dependency updates in one service, run tests, merge, and delete old logs and artefacts past retention.
- Quarterly, half a morning: bigger runtime and image upgrades, plus one recovery rehearsal.
Choose fixed days. Mondays suit the weekly scan because the whole week lies ahead; a mid-month Thursday suits the monthly slot because it avoids release crunches at either end.
Step 4: Create the calendar events
Open your team calendar and create each recurring event. Give it an action-first title such as “Renewal scan” or “Patch bump, service A”. In the description, paste the checklist for that slot and link the register. Invite the rotating owner, not the entire department, so the reminder lands with one person who knows it is theirs.
Step 5: Write the three mini-checklists
Keep each to a handful of lines, with commands or screenshots where they help.
- Renewal scan: open the register, filter to the next sixty days, confirm each item has a ticket, and check that auto-renewal still points at the right address.
- Patch bump: create a branch, update patch and minor versions, run the test suite, read the changelog highlights, merge if green and note anything skipped.
- Log and artefact cleanup: check the largest volumes, confirm retention rules are applied and delete or archive what has aged out.
Step 6: Do a dry run this week
Run the first renewal scan right now, as if the calendar had told you to. You will find gaps in the register, such as a missing owner or a date nobody knows, and fixing them while the stakes are low is the whole point. Resist the urge to polish; a rough register in use beats a perfect one in planning.
Step 7: Give it a visible home
Pin the register and checklists where the whole team will see them, ideally next to the runbooks. A weekly one-line message in the team chat, such as “renewal scan done, nothing due within sixty days”, reinforces the habit and shows your colleagues the routine is real. It also gives managers evidence of progress without any reporting overhead.
Step 8: Connect it to your wider operations
Maintenance rhythm does not live in isolation. If your team already uses automation to speed incident triage, the same discipline helps keep that tooling healthy; this overview of faster IT problem resolution with modern AIOps platforms hints at how many moving parts need regular care. Likewise, teams running machine-learning workloads will recognise the need for scheduled attention to data, models and pipelines, which is covered in an explanation of why MLOps matters for machine-learning success.
Step 9: Look outward once in a while
Teams that serve customers on the web also benefit from seeing how other businesses describe their digital services. For instance, the BHEEKHO website sets itself out as a business-oriented digital hub, and a glance at how that site organises its web, cloud and AI-integration sections is a reminder to schedule a periodic read of your own public pages as well. Add that read to the quarterly slot.
Step 10: Review the routine every quarter
Set a short meeting after each quarterly session to ask three questions. What did the routine catch? What did it miss? What can we automate or drop? Automation is a natural next step for items that have not changed in months; renewal reminders can become scripted checks, and log pruning can become a lifecycle rule. Do the automation only after the manual version has run a few times, so you know what you are automating. A script written from a half-remembered process tends to encode the mistakes of that process; one written from a checklist that has been refined three or four times usually behaves well from the start.
Keep one habit even after you automate: a human still looks at the output on the usual day. A scheduled job that silently fails is just a new way for a certificate to lapse, so give each automated check a visible result, even if it is only a green line in the weekly chat message, and let a person confirm it arrived.
What a sample month looks like
It helps to picture the rhythm in motion. In week one, the Monday scan finds a certificate for a staging domain due in five weeks; it gets a ticket and an owner. On the mid-month Thursday, the patch bump updates one service, spots a failing test caused by a minor library change and defers that single package with a note. The cleanup slot clears an old artefact bucket that had been growing quietly since a retired project. In week three the quarterly rehearsal restores last night’s database snapshot into a scratch instance and discovers that the restore script references a renamed folder; fixing it takes ten minutes. By week four, the staging certificate is renewed, and the team has had four small, calm wins and zero fire drills.
A few example register rows
If you are unsure how to phrase entries, copy this pattern. “Public site certificate, hosted at the main load balancer, renews automatically, owner is the platform rota, check the renewal email address.” “Deployment token for the build service, stored in the secrets manager, rotates by hand every season, owner is the release engineer.” “Base image for the API container, pinned in the build file, review monthly for patch releases, owner is the service team.” Notice that every row names a location, a method and an owner. If you cannot fill all three, that gap is itself a finding.
Troubleshooting: when the routine stalls
- Slots keep getting cancelled. Shorten them and move them away from release days. A fifteen-minute slot survives; a two-hour one does not.
- Nobody updates the register. Make it part of the checklist: every time a new certificate, key or service is created, add a row before closing the ticket.
- Updates keep failing tests. That is information. Note which dependency causes trouble repeatedly and plan a proper migration for it.
- One person does everything. Rotate the owner monthly and have the previous owner sit in for the first handover.
What you should have by the end of today
A register with a few dozen rows, three recurring calendar events, three short checklists and one completed dry run. That is all it takes. Over the following months the routine turns from a project into a quiet habit, and the emergencies you used to dread start turning into two-minute tickets. Keep the cadence, keep the notes and let the calendar do the remembering.