One absence with a medical certificate crosses four systems and one person

Somebody is not coming in and sends a message at seven in the morning. From there a journey begins that almost nobody has ever drawn end to end.

The message arrives on WhatsApp. Somebody reads it and records it in the attendance system. Then they ask for the certificate. The certificate arrives as a photo, two days later, and somebody has to look at it to see what it says. It has to be saved in Drive, in the employee's folder, under the name that company uses. If the absence is long or repeated, somebody has to arrange for the company doctor to visit and verify. And at the end of the month all of that has to reach payroll with the right entry in the right period.

Four systems, one phone call, and a single person carrying the whole journey by hand.

The cost isn't in the data entry, it's in the hand-off

Ask that person how long it takes and they will answer with the minutes of recording the event. It is not many minutes and that is not where the problem is.

The problem is that the fact changes systems five times and none of the five finds out on its own. Every hand-off is done by a person looking at one screen and typing into another.

That is where the errors are born, and they are not exotic errors: the absence that got recorded but never reached payroll, the certificate that covered three days and was entered as one, the file saved under a name nobody will find again, the doctor's visit arranged over the phone and logged nowhere.

And one detail makes these errors cost differently from others: most of them are discovered on the payslip. Which is to say they are discovered when the person gets paid, with the error already paid out, and the correction costs an adjustment, an awkward conversation and, under many agreements, a difference that gets paid anyway.

The same case, today and with an agent

Below is the whole journey, twice. On top, how it runs today: one person going from one system to the next, one at a time. Underneath, the agent below all the systems, reaching them at once.

The steps can be switched off one by one, to see what happens when one of them is left to a person.

The move worth making is switching off a step in the middle, the certificate reading for instance, and watching what happens. The time drops a little. The errors do not drop, because the hand-off is still manual. That is what explains why automating half a process returns far less than it promises.

This object also has a page of its own, in case you want to send just that.

What the agent does that a person cannot

Three things are worth pausing on, because they change the result and they are not obvious.

It does several at once. While it waits for one absence's certificate, it records another event and arranges a third person's visit. A person does one thing at a time, and the journey is long precisely because it is serial.

It reads the certificate. The photo taken in a hurry against the surgery wall is a document, and an agent can pull the date, the days prescribed, the practitioner and the licence number out of it. And it can say on the spot that the image is cropped, which is when saying so is useful. Today that gets discovered weeks later, when somebody goes looking for the certificate to justify a deduction already applied.

It talks outside the chat. Arranging the company doctor's visit is not a system integration: it is writing or calling, passing the address, agreeing a window and then recording what was verified. An agent can do that in natural language, and it is the step that in most operations does not happen, because it means somebody picking up the phone at nine on a Tuesday.

What stays with a person

One thing, and it is worth writing down before starting: deciding whether the absence is justified.

That decision has consequences for somebody's pay and sometimes for their job. A system does not make it. What changes is what reaches the person who does: today it arrives as a loose message at seven in the morning, and with the agent it arrives as an assembled case, with the certificate read, the visit done, the month's history and the event already recorded.

That difference is the whole project. This is not about removing the person: it is about that person having everything in front of them when it is their turn to decide.

How it gets implemented

In stretches, and in this order, which is lowest risk first.

First comes reading the notice and recording it in attendance, in draft mode: the agent assembles the record and a person confirms it. Two weeks of that is enough to see whether the format it writes is the one payroll needs, and what share of drafts gets approved untouched.

Second comes the certificate end to end: asking, insisting, reading and filing. It is the stretch that frees the most time and carries the least risk, because a misread certificate is caught by looking at the file sitting right next to it.

Third comes payroll, and it goes last on purpose. Writing into the payroll system is the most expensive action to get wrong, so it enters once the two earlier stretches have a track record.

Arranging the doctor can enter at any point, because it writes into no critical system.

What to measure

Three numbers, and none of them is how many messages the agent answered.

How many days pass between an event happening and the event being recorded. That one decides whether the spreadsheet describes reality or reconstructs it.

What share of events reached payroll without a later correction. That is the number that translates the project into money, because the later correction is the expensive error.

And how many certificates ended up filed under the right name in the right folder. It sounds minor until the first inspection, or the first employment claim, where the file nobody can find is worth a great deal more than the hours saved filing it.