POC first? Three kinds of companies whose POCs go nowhere

“Let’s just do a POC first.” The moment someone says this, the whole room nods, because it means nobody has to take a position. But I’ve seen too many POCs finish and then sit in a shared folder. Nobody says they failed. Nobody says they succeeded. This post breaks down three kinds of POC that are bound to go nowhere: the one with no defined success criteria, the one that tests the cleanest process, and the one where nobody has the authority to decide when it’s done. It also spells out when a POC really is the right call.

Johnny Yang12 min read
POC first? Three kinds of companies whose POCs go nowhere

“Let’s just do a POC first. We don’t have to decide right away.”

That day in the meeting room, the owner said this and six managers nodded at the same time. It was the most harmonious moment I saw in any implementation meeting that season, because that sentence meant nobody had to take a position. Procurement didn’t have to admit that purchase requests were shouted into a LINE group. Production didn’t have to admit that work reports were all backfilled in one go on Friday afternoon. Finance didn’t have to admit that month-end close still ran on an Excel file whose formulas nobody dared touch. Everyone agreed to try it first. The meeting ended.

A few months later I went back in. The POC’s conclusions file was sitting three folders deep in the shared drive, last modified a long time ago. Nobody said it failed. Nobody said it succeeded. It just stopped there.

I’m Johnny Yang, Brightstream Technology, Taiwan. I’ve led implementation teams for seven years, across 252+ projects in 32+ industries. The question I get asked most is “Can we do a POC first?” and I usually push back with something that makes people pause: A POC is not the problem. The problem is using a POC as a container for postponing a decision. An ERP POC that leads anywhere needs three things before it starts: success criteria fixed tightly enough to be judged (“it runs” doesn’t count; state which number, which action, within what tolerance and what time counts as a pass); a process that actually hurts (not the cleanest one, the one where things go wrong most and people argue most); and one person who, when it’s done, has the authority to say “buy” or “don’t buy.” Missing one of the three, the POC becomes a report nobody opposes and nobody acts on. Missing two or more, you’re not evaluating a system. You’re paying for a stretch of time in which not deciding is perfectly legitimate.

First, you’re right: the instinct to pilot isn’t wrong

I’m not going to talk you out of a POC. The urge to try it first usually comes from a legitimate place.

You may have been burned once. The last system was chosen from a slide deck, and after signing you found the real thing was nothing like the slides. It went live halfway, and the sales support staff still had that Excel file open on screen. You don’t want to lose that money and those six months again. That defensiveness is healthy.

Or you genuinely can’t tell. Every feature the vendor describes sounds right, but you can’t judge whether it will actually work in your company. Your processes have a pile of exceptions nobody else has: one customer on three pricing methods, orders that ship first and get paperwork later, a veteran craftsman whose operation sequence differs from what the engineering drawing says. You really can’t see these without running them through the system once.

Both reasons hold up. The risk with ERP isn’t overpaying. It’s buying the wrong thing and then having to keep using it for three to five years. Running a slice of real data first is rational.

The problem is step two. A POC is a tool for reducing uncertainty, but at most companies its actual effect is postponing uncertainty. In a meeting room these sound identical. The results are opposite.

Type one: nobody wrote down what success means

This is the most common one, and it almost never gets caught at the kickoff meeting, because everyone in the room thinks the answer is obvious.

I’ve asked many times: “When this pilot finishes, what would make you say it passed?” The answers are roughly the same few lines: “See if it runs smoothly.” “See if the staff get used to it.” “See if it fits our process.” These sound like criteria. None of them are. They can’t be judged, and any result can be explained away as “It’s okay, but…”

Without judgeable criteria, something very concrete happens: when the pilot ends, everyone is holding a different ruler. IT sees that the data went in and the integrations work, so it’s a success. The sales support staff have six extra clicks a day, more hassle than Excel, so it’s a failure. The owner can’t see the one report he actually cares about and feels “it doesn’t seem to make much difference.” None of the three is lying, because nobody ever agreed on what to measure.

The meeting usually ends on one line: “Let’s wait and see.” That line is what kills the POC. It isn’t a rejection, so nobody has to take responsibility. It isn’t an approval, so nobody has to move forward. From that moment, the project has no owner.

What do judgeable criteria look like? Here are a few sentences that actually get written in: for every delivery order issued during the pilot, inventory movements must reconcile with a physical count on the floor, and any variance beyond a set range must be traceable to who caused it at which step; when sales support staff create an order with three items and two unit prices, getting from order entry to a generated delivery order must not exceed a set time, and nobody opens a single Excel file along the way; the month-end reconciliation data must come straight out of the system, with no manual merging by finance. What they share: after the run, you can point at the result and say “this one passed” or “this one didn’t.” No grey area.

This is the same logic as acceptance criteria for a full implementation. The only difference is that POC criteria can be fewer and rougher. They can’t be missing. If you can’t be bothered to write success criteria for a POC, you won’t have any on go-live day either. You’ll have a tug-of-war between “I don’t think we can go live yet” and “I think we’re ready.” I break this down further in how to write acceptance criteria that can’t be bent. The POC stage is really a rehearsal for that.

Type two: testing the simplest process

The second type of company did write criteria, ran the pilot, and got great results. The problem is that what they tested was never going to break.

This choice is almost never deliberate. When deciding which process to pilot, the logic in the room is usually well-meant: “Let’s pick a cleaner one first, otherwise there are too many variables and we can’t tell if it’s the system’s problem or ours.” Or more practically: “Production is swamped right now. Let’s not touch them. We’ll test with warehouse receiving and shipping.”

So what gets tested is always the simplest process with the fewest exceptions. Standard products, a single unit price, fixed customers, in and out the same day. Of course the system can run it. You could run this process on an Excel file. It was never your pain point.

The real risk hides where you didn’t test. The things that make you want to switch systems usually look like this: one customer, different projects, different pricing; a batch of goods that goes out to a subcontractor and comes back; a delivery date sales promised that differs from what scheduling calculates; a quotation that needs a cost figure nobody can explain how to calculate; a return that only balances if you split it into two documents. These are what you fight about once a month, every month. They’re also where a new system is likely to hit a wall.

Picking a clean process for the POC means you spent time verifying something you already knew. Worse, it gives you false comfort: “We tested it, no problems.” So you sign, expand the scope, and in the second month after go-live you run straight into the exception you never tested.

My advice has always been the opposite: pilot the part where things go wrong most often. It doesn’t need to be big, but it needs to hurt. Pick the process that makes sales and production glance at each other whenever it comes up. Pick the step someone has to fix by hand on overtime every month. If the new system can run that part smoothly, you basically don’t need to worry about the rest. If it can’t, you find out before paying most of the cost. That is the whole value of a POC.

As for deciding which part to touch first, it’s the same logic as choosing the first process to go live during implementation: find the part with the most pain, the messiest data and the most complaints, not the part that’s easiest to do.

Type three: when it’s done, nobody has the authority to decide

The first two are more or less technical problems. This one is structural, and the hardest to fix.

It goes like this: the POC was done seriously, criteria were written, the right process was chosen, and the report shows that everything that should pass did pass. Then the report goes up and enters a loop with no exit. IT says the business unit has to sign off. The business unit says the budget isn’t theirs. Finance says it has to wait for the annual budget meeting. The owner says “Get your departments to reach consensus first.” Everyone waits for someone else to commit, because everyone knows the first person to say “I think we should buy” is the one who owns it if things go wrong.

There’s a simple test to tell if you’re this company. Before the POC starts, ask: “When this is done, who signs to decide whether we continue?” If you can name a person within three seconds, you’re probably fine. If the answer is a committee, a department, or “we’ll all discuss it then,” you already know how it ends. Not because the system is bad, but because this thing never had an owner from start to finish.

POCs at these companies share one trait: they exist so the decision can keep being postponed. The owner hasn’t actually decided whether to spend the money. Saying “not now” would look insufficiently proactive. Saying “do it” means taking on the risk. “Let’s do a POC first” is the only sentence nobody will object to. What it buys isn’t information. It’s harmony.

Let me say something that may not land well: if your company is in this state, you shouldn’t do a POC. You should deal with decision authority first. A system evaluation won’t solve the problem of nobody in the organization daring to take responsibility. It just makes that problem cost an extra sum of money, then leaves it exactly where it was.

So when is a POC the right call

I’m not saying POCs are useless. In some situations they’re not just right but necessary, and I’ll even ask clients to do one.

One is when you have a very particular piece of logic you can’t explain clearly or draw. Treatment package redemptions in medical aesthetics, multi-level subcontracting in a factory, staged revenue recognition on project-based engineering work. Talk through these with a vendor for three hours in a meeting room and both sides will think they understood. They didn’t. Running real data through once is the only way to confirm.

Another is verifying whether your old data can come across. You have over a decade of data in messy formats, with duplicates and missing fields. Nobody dares guarantee this without testing, and if it goes wrong, it directly decides how many months get added to the implementation timeline.

And one is to watch the people. With the same system, young sales support staff pick it up in two days, while a craftsman with twenty years on the job may resist even logging in. You can’t see this in a slide deck. The only way is to have the people who will actually use it sit down and operate it once. What you’re observing isn’t the system. It’s how people react.

What these three share: you have a specific question you can put into words, and the POC is how you answer it. Conversely, if you can’t say what you want to confirm and just feel “trying it first is safer,” you’re one of the three companies above.

I’ve put the differences in a table. Check it against where you are right now.

CheckpointA POC that leads somewhereA POC that stalls
What it’s meant to confirmOne specific question you can put into words“Trying it first is safer”
Success criteriaAfter the run, you can point at the result and say pass or failSmooth or not, fits or not, used to it or not
Pilot scopeThe part that goes wrong most, with the most exceptionsThe cleanest part, the one least disruptive to current work
Who decidesOne person named before kickoff“We’ll all discuss it then”
What happens at the endA next-step date and an owner“Let’s wait and see”

So what should you do now

If you’re already stuck in a POC

Some readers will realize at this point that they have a POC on their hands that’s half done, or finished and never touched again. It’s fixable, but you have to act.

First, pull it out of “still in progress” status. Pick a day, get everyone involved into one room, lay out what was done, and force a yes or a no. If you never wrote success criteria, write them now and judge the results you already have against them. Criteria written after the fact still beat leaving it hanging.

If laying it out shows you tested the clean process, admit the first round was wasted and run a second one on a process that hurts. If it shows the real problem is that nobody dares decide, then what you need to deal with isn’t the system. Go find the person who actually pays, and put the decision in front of them. If they say no, that’s fine. At least it has a conclusion and you can stop waiting.

If you haven’t started, write three lines tomorrow

No meeting, no proposal. Just a sheet of paper.

Line one: what specific question is this pilot meant to answer? If what you write is “see if it’s a good fit,” don’t start yet. Line two: what result would make me say it passed? Write it precisely enough to check the answers against. If you can’t write a number, write an action. If you can’t write an action, you haven’t thought it through. Line three: when it’s done, who signs off on going forward? Write a person’s name, not a department.

If you can fill in all three, your POC is worth doing. Go do it. If one line won’t fill in, fill that one in first. That’s your real problem right now. The system comes after it.

If you really can’t work it out, thirty minutes with someone who understands implementation is usually more useful than three months of going in circles in your own meeting room.

Found this useful? Pass it on
Prices published · free range estimate

So what does a build to your process actually cost?

From NT$300,000, priced against your spec, with same-scope changes free during the maintenance period. The prices and the estimator are in the first screen — get a range first, you do not have to decide anything yet.

Written scope, then a fixed price · staged acceptance · the code and the data are yours · or just book a free 30-minute diagnostic

Johnny Yang (熊董)
Johnny Yang (熊董)
Founder, Brightstream Technology

Serial founder leading a small team that builds systems into an owner's everyday work.

As a founder
7 yrs
Projects delivered
252+
Industries served
32+
About Johnny