How to Run Your First AI Pilot
Without blowing 50 grand on a strategy deck nobody reads.

I was on a call last week with an operations director at a mid-size distribution company. He'd been told by his board to "look into AI" — a directive so vague it's almost cruel. He had a folder of 12 vendor pitch decks, a budget line item that said "AI Initiative," and absolutely no idea where to start. "Honestly," he said, "I think I'm about to spend fifty thousand dollars on a PowerPoint."

Don't do that. Here's how to run a real AI pilot — one that produces working code, on your hardware, solving an actual operational problem — in 30 days and well under $25,000.

Step 1: Pick the right bottleneck (not the sexiest one)

Every company has a dozen problems AI could theoretically address. Most of them are the wrong first project. Here's how to pick the right one:

The bottleneck test: Is there a single process in your company where one person spends more than 10 hours a week doing something a script could potentially do? Not "something an AI agent could theoretically reason about" — something repetitive, document-driven, and rules-bound?

Good candidates:

• Invoice matching against POs and receipts (AP departments everywhere are drowning in this)
• Lease or contract extraction — finding specific clauses across hundreds or thousands of PDFs
• Dispatch consolidation — matching partial loads, routes, or appointments across multiple input sources
• Intake processing — patient forms, insurance cards, new client onboarding paperwork
• Maintenance log analysis — predicting equipment failure from work order text nobody reads

Bad first projects:

• "An AI strategy for the whole company" — no. That's what you do after you've proved it works.
• "A customer-facing chatbot" — maybe later. Internal operations pay back faster and carry less brand risk.
• "Replace our ERP" — please don't. Your ERP is fine. The gaps between what it tracks and what you need to know are where AI lives.

The right bottleneck has three properties: high volume (lots of transactions), high cost of error (missing it hurts), and low ambiguity (the rules for what's correct are known). Find one of those.

Step 2: Define success in dollars, not dashboards

Most AI pilots fail because nobody agreed on what "working" looks like. The definition can't be "the model had high accuracy." It has to be something your CFO would nod at.

Write this down before you write a single line of code:

If you can't fill this out, you don't understand the bottleneck well enough yet. That's fine — go talk to the person doing the work for an hour. They'll tell you exactly what's broken.

Step 3: Run on your hardware, not someone else's cloud

This is the part where most AI vendors lose me, and it's the single biggest decision you'll make in your pilot.

Enterprise SaaS companies want your data in their cloud because it makes their architecture simpler and their margins fatter. But the moment your customer records, patient data, or contract terms leave your building, you've introduced: compliance risk, data egress costs, vendor lock-in, and a dependency you can't unwind.

Embedded AI runs on your hardware. The code lives in a repo your IT team can access. The model runs on a server you control — either on-premises or in a private cloud instance you own. The data never leaves your environment. If you fire the vendor, the pipeline keeps running because you own the code.

This isn't ideological. It's practical. One client of mine is a medical practice that needed HIPAA-compliant intake processing. They couldn't send patient data to a third-party cloud — not without a BAA negotiation that would have taken six months. So we ran the model locally, on a server they already owned, in a weekend. Zero data egress. Zero compliance headaches. The pipeline is still running a year later.

Step 4: Fix the price, fix the timeline

Enterprise AI engagements are built on billable hours. That's why a Big 4 firm can charge $150,000 for a "discovery phase" that produces a deck. Every week they stretch the timeline is another week of billing.

A real operational pilot doesn't need discovery. The bottleneck is already visible — you just need someone who can look at it and say: "I can build that. It'll take three weeks and cost $18,000."

The fixed-price model changes the incentives. If the builder is paid by the project, not the hour, they're motivated to ship fast and move on to the next bottleneck. If the pilot takes four weeks instead of three, that's their problem, not yours. If it takes two weeks, you win — the thing is running and they still get paid.

Fixed price also forces scope discipline. When you're billing by the hour, it's easy to say "oh, while we're here, let's also..." and suddenly your $20K pilot is a $90K quagmire. Fixed price keeps the question honest: does this specific bottleneck get solved or not?

Step 5: Measure once, then decide

At the end of 30 days, you have three things:

1. A working pipeline that's actually running on your hardware
2. A before-and-after measurement against the success metric you defined in Step 2
3. Documentation your team can use to maintain it

Now you make the simplest possible decision: did it work or not?

If it worked — the pipeline is saving real hours, catching real errors, finding real dollars — you have two options. Option A: hand it to your internal team and walk away. The documentation is there, the code is clean, you don't need the builder anymore. Option B: engage them on retainer ($5,000/month is a common floor) to monitor the pipeline, tune it as data patterns shift, and start scouting the next bottleneck.

If it didn't work — and sometimes it won't, because the data was messier than expected or the process had edge cases nobody documented — you've spent $15,000–$25,000 to learn something concrete about your operations. That's a lot cheaper than a $150,000 strategy deck that also doesn't work, and you have working code (even if it's narrow) instead of slideware.

Either way, you learned something real. The alternative — doing nothing while your competitors figure this out — is the only genuinely expensive option left on the table.

What a real pilot timeline looks like

For the operations director I mentioned at the top, here's what we actually did:

Total cost: $18,000. Total time from handshake to handoff: 28 days. The pipeline is still running.

The one question that tells you if you're ready

Forget "is our data ready?" and "do we have the right culture?" and all the other stall tactics that consulting firms use to delay the start. Here's the only question that matters:

"Is there one operational bottleneck in my company that, if solved, would save enough time or money to justify a $15,000–$25,000 pilot?"

If you can name the bottleneck, you're ready. If you can't, spend a week watching your operations — really watching, not in a dashboard — and you'll find it. There's always a bottleneck. Somebody in your company is doing something tedious right now that a pipeline could do in seconds. That's your pilot.

You don't need an AI strategy. You don't need a data transformation. You need one bottleneck, one builder, and 30 days. Everything else is just delaying the thing that actually works.