Tracking expiring contracts and certificates

The HR team at this company is responsible for tracking when employment contracts, certifications, and medical checks are coming up for renewal. Today, all expiry dates live in a spreadsheet that is opened a few times per week when someone remembers to check it. The HR manager or assistant reviews the dates manually, identifies items expiring soon, and sends reminders to staff or employees. Non-standard cases, which make up about a quarter of the work, require judgment calls about timing or process. Data entry errors sometimes surface during these reviews and need to be corrected on the spot. The process runs about 900 times per year, taking roughly eight minutes each time, and the main risk is that deadlines slip through the cracks when the spreadsheet is not checked often enough.

The company uses an HR SaaS system that holds employee data, but it is not currently integrated with the spreadsheet workflow. The SaaS platform does offer an API, but that feature is only available on a higher subscription tier. Email is the only tool used for sending alerts. The IT function is handled by one person who also manages general support, so any automation solution needs to be simple and low-maintenance.

Traditional code is the right answer here because this process is fundamentally about date arithmetic and threshold-based alerting, which is exactly what simple scripts are built for. The client made the point explicitly during discovery that a scheduled script would beat an AI solution on both cost and reliability, and that assessment is spot on. There is no ambiguity to resolve, no natural language to parse, and no reasoning required for the majority of cases. You need a job that wakes up every day, checks which dates are within your alert windows, and fires off emails. A Python or Node.js script running on a cron job or cloud scheduler does that reliably and cheaply.

The key unlock is upgrading the HR SaaS subscription to the API tier. Right now the spreadsheet is the bottleneck, it gets opened irregularly and it introduces data entry errors. Once the API is available, the script can pull fresh data directly from the source of truth, calculate days until expiry, and send alerts without anyone opening a file. The cost of the API tier upgrade is a small upfront investment that pays for itself quickly when you consider the 120 hours per year currently spent on manual checks.

The 25 percent of cases that involve non-standard contract terms or missing data will still need human judgment, and that is fine. The script should flag those exceptions clearly, route them to the HR team, and let people do what they do best. Trying to automate judgment calls would add complexity and risk for no real gain. The goal is to eliminate the routine work so HR can focus on the cases that actually require their expertise.

Given the one-person IT team, simplicity and maintainability matter as much as functionality. A lightweight script with clear documentation and minimal dependencies keeps the maintenance burden low. If the process rules change, someone can update a configuration file or tweak a threshold without rebuilding the whole solution. This is not a problem that needs a platform, an orchestration layer, or machine learning. It needs a script that does one thing well and gets out of the way.

Traditional Code is the clear winner for this process. The task is fundamentally date arithmetic and threshold-based alerting, which a simple scheduled script can handle reliably and cheaply. The client explicitly stated that a script beats AI on cost and reliability for this use case, and the data supports that judgment. Upgrading to the HR SaaS API tier eliminates the spreadsheet bottleneck and gives the script direct access to employee, contract, and certification data. The script can flag the 25 percent of non-standard cases for manual review, preserving human judgment where it matters while automating the routine date checks that currently consume 120 hours per year.

Hybrid automation scores reasonably well but is essentially what the Traditional Code path already delivers. A script that handles standard cases and flags exceptions for HR review is hybrid in practice, so adding a separate hybrid architecture layer would introduce unnecessary complexity without adding value. The human gate is implicit in the exception-flagging logic, and the one-person IT team benefits from keeping the solution as simple as possible.

RPA could automate the current spreadsheet-based workflow, but it is brittle and expensive compared to a script. If the HR system API is enabled, RPA adds no value because the script can pull data directly. If the API remains unavailable, RPA could scrape the spreadsheet, but the maintenance burden would be high for a solo IT resource and the solution would break whenever the spreadsheet layout changes. AI Workflow and AI Agent paths score poorly because this process has no need for reasoning, natural language understanding, or variable logic. The data is structured, the rules are clear, and a deterministic script will always outperform a probabilistic AI model on cost, speed, and auditability.

The implementation starts by upgrading the HR SaaS system to the API tier. This unlocks programmatic access to employee records, contract expiry dates, and certification information, which is the foundation for eliminating the spreadsheet. The first step is to map the SaaS data fields to the script's data model and validate that all required expiry information is accessible. This typically takes one to two weeks, including time to work with the SaaS vendor's documentation and test API responses with real data.

Next, build the alerting script itself. Python is a good choice here because it has excellent libraries for date handling, API requests, and email sending, and it is widely understood if the IT person needs to hand off maintenance in future. The script should run daily on a scheduler like cron or a cloud function, query the HR API for all active contracts and certifications, calculate the number of days until each item expires, and send email alerts when an item crosses a threshold such as 30, 14, or 7 days before expiry. Crucially, the script must include logic to detect and flag non-standard cases. For example, if a contract has a partial renewal note in a comments field, or if a certification type is not in the known list, the script should tag that record and route it to HR for manual review rather than attempt to process it automatically. Testing this logic with a representative sample of real data is essential to catch edge cases before go-live. This phase usually takes two to three weeks, including time to refine the exception-detection rules based on HR feedback.

Deployment and training follow. Schedule the script to run daily, train the HR team to recognise and act on the alerts, and monitor closely for the first month. Collect feedback on false positives, missed cases, and unclear exception flags, then tune the thresholds and rules accordingly. Once the script is stable and the HR team trusts the alerts, migrate any remaining spreadsheet data into the HR system, retire the spreadsheet, and document the script's logic and maintenance procedures for the IT person. Establish a quarterly review cadence to adjust alert thresholds or add new contract and certification types as the business evolves. The entire implementation typically takes six to eight weeks from API upgrade to full production, with build costs between 3,000 and 6,000 euros depending on the complexity of the HR system integration and the amount of exception-handling logic required.