Source-to-Pay was never the point: The case for Idea-to-Pay

Procurement has spent a decade optimizing what happens after a request arrives. Chris Vessey argues the bigger opportunity is to move upstream—shaping demand from the moment an idea becomes intent.

Every procurement conference for the last five years has argued the same questions in different costumes. Intake first, or sourcing first? Suite, or best-of-breed? Modules, or platform?

It's the wrong argument.

Every version makes the same quiet assumption: that the journey starts at the point procurement can see it.

But it doesn't. It never did.

For a decade, our industry has transformed procurement in pieces. A tool for intake. A tool for risk. A tool for contracts. Point solutions for sourcing, supplier management, invoice matching. Each one, in isolation, was probably the right call.

But add them up and you have a function that spends its days reconciling the seams between systems that were never designed to know about each other.

Every part moved forward. But nothing moved together.

We didn't fail to transform. We transformed at the wrong altitude, optimizing the parts of the process we could already see and leaving the part where the decisions actually get made largely untouched.

I spent twenty years on the buying side before I ever worked for a vendor, and I signed off on plenty of those point-solution business cases myself. The tools did what the slides promised.

The problem becomes visible between them, where the actual decisions—what to buy, from whom, on what terms, funded by what budget—are still being made by a person juggling browser tabs.

The nicer place to wait

If there's a single villain in this piece, it's intake. And I say that carefully, because intake wasn't wrong.

Intake was the industry admitting that the journey started too late. That was real insight.

But it answered a scope problem with an experience fix: a glossy "front door" on the same fragmented building behind it.

Intake moved the start line back by a few weeks. It didn’t move it back to where the decision actually gets made, which is usually months earlier, in someone's head, before a single form exists to capture it.

Intake didn't fix the start line. It just built a nicer place to wait.

At best, it was a nice bus stop.

Start at the idea, not the request

Roughly 70% of spend under influence isn't necessarily a failure of execution. It's the ceiling of an architecture that begins at the request.

You can restaff it, automate it, and add another approval workflow, but the constraint remains because it isn't about effort. It's about where the tape measure starts.

Getting closer to 90% requires an architecture that begins at the idea.

The opportunity isn't hiding in the marquee sourcing events everyone already fights over. It's in the long tail: direct and indirect spend, requests too small to justify a form, decisions made in a Teams message that never become a ticket at all.

As ORO Labs CEO Sudhir Bhojwani puts it:

"Running a sourcing event is already too late. Nobody thinks about running a sourcing event as the first thing they do. 'Idea' is the right word. Not 'intake.'"

That's the fundamental shift from Source-to-Pay to Idea-to-Pay: expanding procurement's scope upstream to the moment a business need begins to take shape.

Fix scope, not just speed

When you change scope rather than speed, procurement gets the opportunity to shape decisions while they're still decisions.

Risk can be evaluated before commitment instead of discovered after it. Budget stays connected to the process that's spending it. Supplier options surface while they're still options—not after someone has already committed to a single name.

And yes, cycle times fall.

But speed is the consequence, not the goal.

Chase speed directly and you'll ship a faster version of the wrong architecture. Start earlier and procurement can influence the things that actually determine value: demand, specifications, suppliers, risk, and spend.

I've seen what that looks like at real scale. At DPW New York, Coca-Cola described the problem perfectly:

"We were expecting our users to be the human integrator among the different systems and the different steps."

That's not a training problem. It's not a change management problem. That's the architecture handing its own job to the person least equipped to do it.

Why "more agents" doesn't fix this

There's an obvious question: can't agentic AI just paper over the seams?

Not by itself.

An agent inside the wrong architecture does the wrong work faster. It doesn't move the start line. It just automates the wait.

Agents can transform how procurement work gets done. But adding more of them doesn't answer the underlying questions of where procurement engages, what context it has when it does, and how work moves across the enterprise.

That requires a different architecture.

Where does your process actually start?

So here's the question I'd genuinely put to you: where does your process start, and where should it start?

If the honest answer is "when I receive a formal request," then you're reactive by design. No amount of automation or agent deployment fundamentally changes that, if the architecture underneath it still starts at the request.

We spent a decade fixing the constraint we could see: speed.

The bigger opportunity is scope.

Source-to-Pay was built around the request. Idea-to-Pay starts earlier—at the idea, while procurement still has the opportunity to shape what happens next.