Recruitment by Obfuscation.

There is a deceptively simple assumption at the heart of modern recruitment. A candidate finds a job, clicks Apply, fills in a form, uploads a CV and eventually receives some variation of “Application submitted.” From that moment on, both candidate and employer tend to behave as though something very straightforward has happened: a person applied to a company.

Increasingly, I am not convinced that this description is accurate.

Recruitment has accumulated layers. Job discovery platforms, aggregators, matching services, recruiting marketplaces, partner networks, sourcing systems and application-routing tools now sit between the person looking for work and the company supposedly looking for that person. Individually, many of these services solve perfectly legitimate problems. They help employers distribute vacancies, help candidates discover positions they would otherwise never encounter, normalize job data, reduce repetitive form filling and give smaller companies access to a much larger pool of potential employees.

There is nothing inherently wrong with any of that. The problem begins when these layers become invisible.

What appears to the candidate as a direct relationship may actually be a chain of independent systems. A job discovered on one platform may have originated somewhere else entirely. Clicking Apply may redirect the candidate to another service, which may process the application internally, perform some form of matching, pass it through another partner, submit it to an applicant tracking system or route it through yet another layer before it reaches the company.

If it reaches the company at all.

From the outside, the process still looks wonderfully simple: find job, apply, wait. Underneath, however, the application may be travelling through what increasingly resembles a recruitment supply chain. And once that happens, an unexpectedly difficult question appears: at what point can we truthfully say that the candidate has applied to the employer?

This is not merely a semantic distinction. It creates a serious observability problem.

A candidate sees the name of a company attached to a vacancy and reasonably assumes that submitting an application means that company now has the application. Yet the candidate usually has no way of knowing whether the data was actually delivered, transformed, ranked, filtered, deduplicated, delayed or rejected somewhere upstream. They cannot tell whether the vacancy is still active at the source, whether an intermediary copied it days or weeks earlier, whether another platform has inserted its own matching logic into the process or whether the company itself ever became aware that this person existed.

The candidate knows where the application journey started. What is increasingly unclear is where it ended.

It is tempting to describe this simply as candidate obfuscation, but the more I look at the problem, the more incomplete that term feels. Employers are being obfuscated too.

Imagine a company publishes a perfectly legitimate vacancy. The role is then indexed, redistributed, syndicated or otherwise surfaced through several external services. A qualified candidate encounters one of those representations, applies, receives confirmation and then hears nothing.

From the candidate’s perspective, the conclusion is obvious: “I applied to Company X and Company X ignored me.”

Perhaps it did.

But perhaps Company X never saw the application.

That distinction matters enormously, because the reputation damage still lands on the employer whose name appeared on the job. The candidate does not blame an invisible routing layer they did not know existed. They blame the company they thought they were speaking to.

Now reverse the direction and the problem becomes equally unpleasant. An employer may open a vacancy and discover that it has received thousands of applications. On paper, that sounds like extraordinary market interest. In reality, the number may represent a mixture of direct applications, redistributed listings, automated submissions, duplicate candidates arriving through several channels and loosely matched applicants who never deliberately selected that particular employer in the first place.

At that point, both sides are looking at numbers that seem meaningful but may describe very different things.

The candidate says, “I sent a thousand applications.”

The employer says, “We received two thousand candidates.”

Neither number necessarily tells us what we think it does.

A thousand application events do not necessarily mean a thousand employers received an application. Two thousand incoming records do not necessarily represent two thousand distinct people who intentionally chose that company. Even a rejection rate becomes difficult to interpret when we do not know where the rejection actually happened. Was it the employer? The ATS? A matching service? An intermediary filter? A stale listing? Or did the application simply fail to complete the journey while every system involved reported that its own local operation had succeeded?

This uncertainty becomes even more important when considered alongside automated screening. In an earlier article, I argued that AI can be useful as decision support in recruitment, but that it should not become the decision maker, directly or indirectly. If a recruiter only sees candidates an algorithm has already allowed through, then saying “a human makes the final decision” is largely cosmetic. The meaningful decision has already taken place upstream.

But there is an even earlier question that deserves attention.

Did the candidate ever reach the system that supposedly evaluated them?

These are two different problems, and they reinforce one another. One concerns what happens when an application is screened. The other concerns whether the application entered the relevant screening process at all.

Modern hiring increasingly involves several independent layers, each controlling a different part of the journey. One system controls discovery. Another may control distribution. Another performs matching. Another may rank or screen. Another stores the application. Eventually, perhaps, a recruiter sees a human being.

Every one of those components may be defensible when examined independently. The end-to-end system can still be broken.

Engineers have seen this story many times. A distributed system can consist entirely of services that report themselves healthy while the user-facing transaction fails completely. Every dashboard is green. Every local request returned success. Yet the customer still cannot complete the operation.

Recruitment increasingly feels like such a system.

The job exists. The candidate exists. The company genuinely needs someone. The candidate may even be remarkably well suited to the role. Each platform in the chain may truthfully report that it performed its particular function. Yet the two people who needed to find each other never meet.

And because there is little or no end-to-end traceability, nobody can say precisely why.

The natural reaction to the resulting chaos has been more automation, which unfortunately creates its own feedback loop. Employers facing overwhelming application volumes introduce stronger automated filtering. Candidates facing near-total silence respond by increasing application volume, often with tools that automate discovery, tailoring and submission. Higher volume produces more noise, which justifies more aggressive filtering, which encourages candidates to optimize harder and apply even more widely.

The two sides begin automating against each other.

Employers automate rejection because there are too many candidates. Candidates automate applications because there are too few responses. Intermediaries optimize for matching, distribution, engagement or submission volume somewhere between them. What the system creates with impressive efficiency is not necessarily better hiring, but more transactions.

This distinction matters.

A platform may be able to demonstrate that it generated ten thousand applications. An employer may care about how many genuinely qualified people reached a hiring manager. A candidate may care about whether anyone ever considered their experience. These metrics are related, but they are not equivalent.

If the ecosystem rewards application events rather than successful human connections, then it should not surprise us when the number of applications rises dramatically while everyone involved becomes less satisfied with recruitment.

This is also why I have become more cautious about assigning responsibility to the largest and most visible job platforms.

They are the obvious targets because they are the part candidates can actually see. If someone finds a vacancy on a major job board or search engine, applies and receives silence, that visible platform becomes emotionally associated with the failure.

But visibility and responsibility are not the same thing.

A discovery platform may have done exactly what it promised: it helped the candidate find a real vacancy. The failure may have happened after the candidate left it, inside an intermediary recruiting service, a matching platform, an external application workflow or an ATS configuration over which the original platform had little or no control.

That does not mean the major platforms have no responsibility. They absolutely should care about stale listings, misleading advertisements, job authenticity and the quality of the ecosystems into which they send candidates. Visibility creates responsibilities of its own.

But blaming the first recognizable logo in a complex pipeline is not necessarily more useful than blaming a browser because the application behind a website returned an HTTP 500. The browser showed you the failure. It did not necessarily cause it.

This is precisely why the recruitment ecosystem needs something it currently seems to lack almost completely: end-to-end application provenance.

A candidate should be able to know whether an application actually reached the employer. An employer should be able to see how the application arrived and which systems processed it beforehand. A rejection should have an identifiable origin. A vacancy that closes should propagate that state through the distribution chain. Duplicate applications should be recognizable without silently penalizing the candidate. Most importantly, the word “application” should stop being used as though submission, delivery, automated screening and human review were the same event.

They are not.

None of this requires exotic technology. We solved comparable traceability problems years ago in other industries.

When a package crosses several logistics networks, we expect tracking. When a payment travels through several financial institutions, we expect a transaction trail. When a request crosses twenty microservices, engineers implement distributed tracing because diagnosing failures without it quickly becomes impossible.

Yet a job application can cross several commercial systems, disappear somewhere along the route and leave everyone involved guessing about what happened.

The candidate assumes they were rejected.

The employer assumes no suitable candidate applied.

The intermediary counts another successful submission.

The market then looks at the resulting numbers and begins talking confidently about talent shortages, applicant surpluses and candidate quality.

Perhaps some of those conclusions are correct.

But I increasingly wonder how much of what we believe about the current hiring market is partly an artifact of the machinery sitting between employers and candidates.

The real problem may therefore be broader than ghost jobs, bad recruiters, aggressive ATS filtering or badly written job descriptions. We may have created a recruitment supply chain in which no participant can reliably observe the complete transaction.

And once nobody can see the whole system, nobody can confidently tell where it failed.

Before adding another matching algorithm, another screening model, another recruiting marketplace or another automated application agent, perhaps the industry should answer a much simpler question.

When somebody clicks Apply, did the company ever see them?