Full Cycle Recruiting: The 5 Stages and How to Systemise It

It is a stack of small ones. Every role you take on produces more than a dozen separate documents before it closes, and each of them exists whether you formally write it or not. Here is the list most agencies would recognise from their own last search:

• The role brief
• The success criteria
• The market map
• The approach list
• Candidate summaries
• The candidate scorecard
• The shortlist pack
• Interview confirmations
• Interview feedback notes
• Reference summaries
• The offer comparison
• The weekly client update
• The placement report

Thirteen documents, and that is a straightforward role. Every one of them is written by hand, from notes somebody already took on a call. And because nothing starts them automatically, they get written late, or written differently depending on who picked the role up, or quietly not written at all.

This is the gap between having a process and running one. Across 650+ recruitment-agency audits over the last three years, the pattern almost never changes: the owner can describe their process perfectly out loud, and no two searches in the system actually look the same.

An undefined process costs you the client relationship and your team's capacity, long before it costs you hours. The usual argument for documenting one is efficiency, which is the least interesting reason. The real cost is paid by two people, and neither of them is you.

The client gets a different experience depending on which week it is and who ran the role. Their brief comes back to them in one document and then never appears again. Candidates arrive as narrative write-ups in three different shapes, so there is no honest way to compare them side by side. Updates turn up when someone remembers, which trains the client to chase.

Your team, in a boutique running two or three consultants, starts from a blank page on every search. A new consultant gets handed a folder of old examples and told to match the tone. Nobody can tell, at a glance, whether a live role has had everything done to it that it should have. And the depth of a candidate assessment quietly becomes a function of how busy that week was, rather than what the role needed.

There is a commercial version of this argument too. A business where delivery lives in the founder's head is worth less than one where it lives in a system, because the first one cannot be handed to anybody. If you have ever wondered why your agency stopped growing, this is usually sitting somewhere near the answer.

One person owning all five stages is the most efficient way to run a role, right up until three roles arrive in the same week. Then it breaks, and it breaks in a predictable order.

The stages that get dropped first are always the documented ones: the scorecard, the weekly client update, the placement report. The calls and the interviews keep happening regardless, because a candidate chases you for feedback and a client chases you for a shortlist, and nobody on earth chases you for a scorecard. That is a pressure problem.

For a boutique running two or three consultants, this is why delivery quality tracks the calendar rather than the person. The same consultant produces thorough work in a quiet week and thin work in a busy one, and the client experiences that as inconsistency without ever knowing why.

There are only three ways out. Hire, and split the full cycle into a 180 model where someone else owns half the role. Work longer hours, which is what most owners actually do. Or keep the full cycle model and stop the documentation depending on anybody remembering it, which is what the rest of this piece is about.

Every stage needs four things: a trigger, an input, an output and a gate. That is the part to write out for your own process. Four columns per stage, one page in total, and you can finish it in an afternoon without buying anything.

The trigger is an event: a stage move, or a note saved with a set type, something that fires on its own without anyone needing to remember it.

The input is what already sits on the record at that moment. Call recordings, interview notes, the CV, the signed criteria. You are almost never writing from nothing, which is exactly why the work feels so repetitive.

The output is one named document in your format, such as the scorecard or the shortlist pack, specific enough that somebody can ask where the scorecard is and get a straight yes or no.

The gate is who approves it before a client or candidate sees it. Every stage has one. Build the gate before you build anything else, because a process that can reach a client unreviewed will be switched off the first time it embarrasses somebody.

Every candidate score has to cover two things: whether they can do the job, and whether they will actually join and succeed. Stage three is where most recruiting processes are thinnest, because scoring properly is slow and there is always another call to make. It is also the stage with the most to gain, and the fix is structural rather than effortful.

Score on two axes instead of one. The first is capability: can this person do the job, measured against the criteria the client signed at stage one rather than a generic competency list. Five criteria is usually right. Scoring every candidate against the same five is the entire reason a client can compare them.

The second is whether they will actually join and succeed. Notice periods, relocation, family timing, live processes elsewhere, counter-offer risk, and whether they have walked into a situation like this one before. Searches rarely collapse because someone could not do the job. They collapse on the second column, and almost nobody scores it.

AI drafts the documents and a person decides. Once the four columns are written down, the case for that split makes itself. Your ATS is the system of record and stays that way. A model connected to it reads the live record rather than a copy, fills your template, and puts a draft in front of a consultant with the evidence behind every line. The consultant validates, challenges, decides and approves. We have installed this structure inside 100+ recruitment businesses as a Claude operations layer.

Four things stay with a person, permanently. Who makes the shortlist. Anything sent to a client or candidate without approval. The relationship conversations, meaning the briefing call, the difficult feedback and the offer negotiation. And anything where being wrong is expensive and hard to notice.

That last one is the real test. Automate the work where a mistake is obvious the moment you read it. Keep a human on the work where a quiet error costs you the account. If you want the mechanics of connecting a model to your stack, the Claude for Recruiters guide walks through it, and the operations guide covers the wider back office.

Three steps, and the first two cost nothing.

1. Name your stages. Five covers almost every agency. Write them down once, in the words your team already uses, so they stop being five different processes in five different heads.
2. Fill the four columns for each one. Trigger, input, output, gate. One page. The gaps will be obvious the moment it is on paper, and the stages with no trigger and no gate are your answer.
3. Connect exactly one. Pick the document costing you the most hours and build that one only. If it works, your team will ask you for the rest, which is a far better position than announcing a rollout nobody asked for.

The order matters more than the speed. Agencies that try to automate a process they have never written down end up automating the inconsistency. Write the page first. The page is the asset.