Chapter 5: The First Win

Oscar studies Sam’s legal pads for three days. Then he calls her.

“I want to start with purchase order processing,” he says. “Not because it’s the biggest problem. Your bank reconciliation is actually a bigger time sink. But PO processing is the most visible. It’s where errors happen, it’s where Henderson’s feels the pain, and it’s where a win will be impossible to argue with.”

Sam appreciates this. She’d been bracing for a pitch to automate everything at once.

“Here’s what I want to build,” Oscar says. “And I want you to tell me if I’m wrong.”

He describes it step by step:

A purchase order email arrives in the shared inbox. The system detects it automatically, not by subject line, which is unreliable, but by checking the attachment type and scanning the first few lines. It downloads the PDF and sends it to an AI extraction engine that reads the document and pulls out every field: customer name, PO number, line items, quantities, grades, pricing, shipping instructions.

That extracted data gets matched against MapleCo’s customer database and price list. If everything checks out, known customer, valid products, correct pricing, the system creates a draft sales order in QuickBooks and a corresponding supplier order for the Quebec producers.

If something doesn’t check out, unknown customer, mismatched price, a product they don’t carry, it flags the exception and sends it to Lisa with a clear summary: “Henderson’s PO #0851, everything matches except line 3: they ordered ‘Maple Butter, 500ml, 36 units’ but our catalog lists Maple Butter in 375ml. Please clarify.”

Lisa reviews the exception. Makes one decision. Clicks approve or corrects the line. The system handles everything else.

“The robot does all the prep,” Oscar says. “Lisa reviews a clean summary. She clicks once. The robot does all the follow-through.”

Sam is quiet for a moment. “How long does this take to set up?”

“Four to six weeks for the full build. First two weeks are discovery and design, which we’ve mostly done. Next two weeks are building and testing. Final one to two weeks are running it alongside Lisa’s manual process to make sure nothing’s missed.”

“And the cost?”

“Thirty-five thousand,” Oscar says. “That covers discovery, the AI extraction engine, the QuickBooks integration, testing, and three months of support after go-live.”

Sam does the math. Jordan cost $65,000 in year one and didn’t fix the process. CloudSyncPro cost $30,000 and sat on a shelf. This costs less than either. It doesn’t call in sick, doesn’t need training, and processes orders at 3 AM without complaint.

“What about the human approval step?” Sam asks. “Lisa still reviews everything?”

“For now, yes. Eventually, for routine orders from known customers with standard pricing, the system can process them straight through and Lisa only sees exceptions. But we start with full review. Trust is earned, not assumed.”

Sam thinks about the Zapier disaster. Trust is earned.

“Do it,” she says.

The build takes five weeks.

Oscar’s team is small. He does the architecture and the AI extraction himself, with a developer handling the QuickBooks integration.

“What happens when a customer orders a grade you’re out of stock on?”

“What if the PO has a typo in the product name?”

“What does Lisa do when a PO arrives in a format she hasn’t seen before?”

“What if the price on the PO doesn’t match your price list. Who wins?”

Every answer reveals another edge case that a quick-and-dirty build would have missed. Oscar maps each one, decides whether the system should handle it automatically or flag it for a human, and builds accordingly.

During the second week, Jordan makes a suggestion. He’s been watching the edge case mapping and he has an idea.

“Why don’t we just have the system reject anything it can’t parse perfectly? We can handle the weird ones manually for now and train the system on them later. That way we launch faster.”

Lisa looks up from her desk. “How many is ‘the weird ones’?”

“I don’t know. Five percent? Ten?”

“It’s closer to twenty. And those twenty percent include every Henderson’s PO, because Henderson’s includes a cover sheet that the system has to learn to skip. They include every PO from the Niagara restaurants, because half of them still fax. They include every new customer, because the system won’t recognize the format. You want to manually handle twenty percent of our orders so you can launch a week earlier?”

Jordan’s face reddens. “I’m just saying we don’t have to be perfect on day one.”

“We don’t. But we have to be correct for Henderson’s on day one. Because Henderson’s is thirty percent of our revenue and they just sent us a scorecard that says we’re below threshold on accuracy. If the new system bounces their POs into a ‘handle manually’ pile, we haven’t solved anything. We’ve just given the problem a new address.”

The room is quiet. Oscar doesn’t intervene. He lets it sit.

Jordan looks at Lisa for a long moment. Then he nods. “OK. Show me the Henderson’s cover sheet thing. I want to understand the format.”

It’s not a resolution. It’s the beginning of one.

Lisa, who has been quietly observing Oscar’s process with the cautious respect of someone who’s seen her workflows described by outsiders before (always incorrectly), says to Sam later: “He’s the first one who’s bothered to ask how I actually do it, instead of telling me how I should be doing it.”

Though even Oscar gets it wrong once.

During the second week of the build, he presents his draft of the pricing logic to Lisa. “When a PO comes in, the system checks the master price list. If the customer has a contract rate, it uses that instead. If neither matches the PO price, it flags for review.”

Lisa reads it. “That’s wrong.”

Oscar looks up. He doesn’t get defensive, but he’s clearly surprised. “Which part?”

“The order. You check the contract rate first, not the master list. If there’s no contract, then you fall back to master. And for Henderson’s, you don’t check either one first. You check the PO price against the contract, and if Henderson’s is quoting lower than our contract rate, you flag it, because it means they’re working off an old version and we need to send them the updated agreement before we fill the order.”

Oscar stares at his notes. “That’s not what the process documentation said.”

“The process documentation said ‘check pricing.’ It didn’t say which pricing, in what order, with what exceptions. Because I wrote that documentation at 8 PM after mapping three processes on legal pads and I was tired.”

Oscar crosses out two lines in his notebook and rewrites them. “This is why I don’t build from documentation alone. The documentation is always version one. The person is version twelve.”

Lisa almost smiles. Almost.

Oscar also spends an afternoon in the warehouse with Ray. He doesn’t bring a laptop. He brings a notebook and a coffee and sits on a folding chair near the shipping desk for three hours. Ray, despite himself, starts talking.

“The packing slips don’t always match the sales orders,” Ray says at one point. “So I check against both. And sometimes neither one is right, because someone updated the order after the slip was printed but before I pulled the pallet.”

Oscar writes this down. “How often does that happen?”

“Once or twice a week. I’ve got a system.” Ray gestures vaguely at the whiteboard and a binder that looks like it predates email.

“Your system works,” Oscar says. “I’m not going to replace it. I’m going to make sure the data that reaches you is right before it gets here.”

Ray considers this. “That,” he says, “would be new.”

Week three: testing.

Oscar runs a batch of real purchase orders, last month’s, which Lisa already processed manually, through the new system. The AI extraction correctly reads 47 out of 50 POs. The three it misses are: a handwritten fax from a restaurant that uses carbon paper (Sam laughs, Oscar does not), a PO that was scanned at a 45-degree angle, and one from a new customer whose format the system had never seen.

“Ninety-four percent on the first pass,” Oscar says. “After I train it on the three misses, it’ll be above ninety-eight. The remaining two percent will always be exceptions, and that’s fine. That’s what Lisa’s for.”

He adjusts the system. The second batch runs at 49 out of 50.

Week five: go-live.

They don’t flip a switch. They run the new system alongside Lisa’s manual process for a full week. Every PO gets processed both ways. At the end of each day, they compare results.

On Monday, the system matches Lisa perfectly on 8 out of 10 orders. The two mismatches are both pricing discrepancies: the system used the master price list, but two customers are on old contract rates that exist only in Lisa’s head.

Oscar adds a customer-specific pricing table. Tuesday: 12 for 12.

By Friday, the system has processed 53 purchase orders with zero errors. Lisa processed the same 53 orders manually, as she normally would, and found the automated version caught a pricing error that she had missed.

“The system caught my mistake?” Lisa says, sounding half-offended and half-impressed.

“The system never gets tired at 3 PM,” Oscar says. “That’s not a knock on you. That’s the point.”

The following Monday, they go live for real.

Sam arrives at 8:15. She opens her laptop. On her dashboard, a simple web page Oscar built that pulls from QuickBooks and the order tracking system, she sees:

12 POs received overnight. 10 processed automatically. 2 flagged for review.

She clicks into the exceptions. The first one: a new customer whose company name doesn’t match any record. Easy. Lisa will confirm it’s a legitimate new account and add them. The second: a PO requesting a product that was discontinued last month. Lisa will call the customer and suggest an alternative.

Two decisions. Two clicks. Five minutes.

The same twelve orders would have taken Lisa two and a half hours to process manually. Price checks, cross-references, data entry, spreadsheet updates, all of it handled while Sam was sleeping.

Sam stares at the dashboard and feels something she hasn’t felt in a very long time.

Space.

Not free time. She has plenty to do. But mental space. Breathing room. The feeling of arriving at work and not being immediately underwater.

She calls Oscar. “It works.”

“I know. I was watching the logs.”

“That’s a little creepy.”

“That’s monitoring. We’ll talk about that too.” He pauses. “Want to see what actually happened while you were sleeping?”

He pulls up the log on his laptop and walks her through it.

“Step one: the system scanned your inbox and found twelve PO attachments. Different formats, different layouts, some with cover sheets. That’s the AI part — it reads documents it’s never seen before and pulls out every field. Step two: each extracted order gets checked against your customer database and price list. Known customer? Valid product? Correct price? That’s not AI, that’s just rules. Yes or no. Step three: clean orders go straight to a draft sales order in QuickBooks and a supplier order for Quebec. Anything uncertain goes to Lisa’s queue with a plain-English summary of what didn’t match. Step four: every action gets recorded. Every decision the system made, every field it extracted, every match it confirmed — logged and traceable. If Henderson’s ever asks ‘why did you ship this,’ you can show them the exact chain. Step five: I get alerts if anything looks off. Processing time spikes, error rates change, a customer’s order pattern shifts suddenly.”

Sam looks at the log. “The AI part is actually smaller than I thought.”

“It usually is. Most of the work is boring validation and routing. The AI just handles the messy front door — reading documents that don’t follow rules. Everything after that is just logic.”

Three weeks in, Sam is a convert.

The numbers are hard to argue with. Purchase order processing has gone from 12.5 hours per week to approximately 45 minutes of exception review. Error rate: zero, because every PO is validated against the price list and customer database automatically, with no tired-human-at-3-PM risk.

Lisa has 10 extra hours a week. She’s using them to call customers she hasn’t spoken to in months, reconcile outstanding invoices that have been sitting in AR for weeks, and, for the first time, analyze which products have the best margins by customer segment.

“I didn’t know I could do this kind of work,” Lisa tells Sam one afternoon, looking up from a spreadsheet that she built herself, not as a workaround, but as an actual analysis tool. “I always thought I was the data entry person.”

“You were never the data entry person,” Sam says. “You were the person we couldn’t afford to waste on data entry.”

Lisa is quiet for a moment. Then: “That’s the nicest thing you’ve said to me in eight years.” She’s joking. Mostly.

Jordan, for his part, has been watching the system closely. He’s fascinated by the dashboard, the error handling, the way exceptions get routed. He starts asking Oscar questions. Oscar, who will patiently explain anything to anyone who’s genuinely curious, starts teaching Jordan how the monitoring works. Jordan’s eyes light up in a way Sam hasn’t seen since his first week.

Henderson’s hasn’t said anything. No complaints. No follow-up emails about tracking numbers. Orders go out correctly and on time. The silence, Sam realizes, is the sound of things working.

Ray notices too, in his own way. The packing slips arriving at the warehouse are suddenly, consistently correct. “Huh,” he says to no one in particular, examining a packing slip on a Tuesday afternoon. “Third day in a row nothing’s wrong.” He sounds almost suspicious, like a man who’s been burned too many times to trust a streak.

Here is the thing Sam hasn’t told anyone.

She’s been processing Henderson’s POs herself. By hand. The old way.

Not all of them. Just the big ones. The weekly standing orders for the US distribution centers. The high-value seasonal orders. The ones where, if something goes wrong, Henderson’s notices within hours.

She tells herself it’s temporary. Just until she trusts the system. Just until she’s sure it handles the Henderson’s cover sheet correctly, the USD pricing, the volume discounts, the specific product codes Henderson’s uses that don’t exactly match MapleCo’s internal catalog.

The system has been processing Henderson’s POs perfectly for three weeks. She knows this because she’s been comparing her manual entries against the system’s output every night. They match. Every time. The system is right and Sam keeps processing them by hand anyway.

She can’t stop. That’s the part she won’t say out loud. The system works and she can’t bring herself to let it work. Because if the system handles Henderson’s, then Sam isn’t needed for Henderson’s. And if Sam isn’t needed for MapleCo’s biggest account, then what, exactly, is Sam needed for?

She doesn’t think about it in those terms. She tells herself it’s prudent. Due diligence. Protecting the relationship. What she’s actually doing is protecting her own role as the indispensable person, the one the business can’t run without, the one who has to check everything because checking everything is who she is.

On a Thursday afternoon, Sam is manually entering Henderson’s weekly standing order. It’s the forty-third PO she’s touched this week, because she’s doing the Henderson’s ones on top of her regular work. She’s tired. She’s been at her desk since 7 AM. She’s answering emails between line items.

She enters the standing order: 48 cases Grade A Amber, 24 cases Dark, 12 cases Golden. She cross-references the pricing. She creates the supplier order. She updates the tracker.

She doesn’t notice that she typed 24 cases of Golden and 12 cases of Dark. She transposed two numbers. The exact kind of error she’s made before. The exact kind of error the automation was built to prevent, because the automation cross-references every line item against the original PO and flags discrepancies.

The order goes to the supplier. The supplier ships 24 cases of Golden and 12 cases of Dark. Henderson’s receives the wrong quantities. Their warehouse rejects the shipment because it doesn’t match the PO. MapleCo gets a call.

Lisa is the one who traces it. She pulls up the PO in the system and sees two entries: the automated one (correct) and Sam’s manual one (wrong). The automated entry was created at 2:47 AM. Sam’s manual entry was created at 3:12 PM. Sam’s manual entry is the one that generated the supplier order, because Sam set the system to defer to manual entries when both exist.

Lisa walks into Sam’s office and closes the door.

“The Henderson’s standing order went out wrong. Wrong quantities. Dark and Golden were flipped.”

Sam’s stomach drops. “How?”

“You entered it manually. The system had it right. Your entry overrode it.”

Sam stares at her screen. She can feel it coming. Not from Lisa. From inside her own chest. The thing she’s been avoiding.

“Sam. Why are you still entering Henderson’s orders by hand?”

“I just wanted to make sure…”

“The system has been right every time. You’ve been checking it every night. I know because I see the comparison reports you pull.” Lisa’s voice is steady. Not angry. Something worse than angry. Honest. “The system would have caught this. You’re the reason it didn’t.”

Sam doesn’t say anything.

“I’ve spent eight years being the person who catches mistakes. I’m not going to watch you become the person who creates them because you can’t let go.”

Lisa stands up. She pauses at the door.

“Let the system work, Sam. That’s what you paid for.”

She leaves. Sam sits alone in her office. The Henderson’s PO is still on her screen. The correct version, the one the automation generated at 2:47 AM while Sam was asleep, sits right next to her wrong one.

She stares at both entries for a long time.

Then she deletes her manual override settings. Every single one.

It’s the hardest thing she’s done since taking over MapleCo. Not because it’s complicated. Because it means admitting that the system is more reliable than she is. That the business doesn’t need her fingers on every keyboard. That being essential and being effective are not the same thing.

Gerald’s words come back to her: You didn’t build this business to be its best employee.

She calls Henderson’s, explains the error, arranges the correction. She doesn’t make excuses. She says it was a manual processing mistake that won’t happen again. And for the first time, she means it structurally, not just as a promise.

This is where Sam makes her next mistake. But it’s a different kind of mistake now.

She’s shaken by the Henderson’s error. She’s embarrassed. And embarrassment, in Sam, turns into urgency. She wants to fix everything, fast, to prove that the system works and that she can trust it and that the whole experiment wasn’t a waste. The part of her that measures her worth by how many problems she solves simultaneously is screaming catch up.

“Oscar,” she says on a call, “I want to automate the bank reconciliation next. And the shipping notifications. And the monthly reporting. Can we do all three at once?”

There’s a pause on the other end of the line. The kind of pause Sam will learn to recognize as Oscar choosing his words carefully.

“No.”

“No? Why not? I’ve already wasted weeks by… by doing the Henderson’s thing manually. I need to make up the time.”

“You don’t make up time by going faster. You make up time by not breaking things. The PO automation worked because we spent five weeks doing discovery, mapping edge cases, and running it alongside Lisa before we trusted it. If we rush three more processes at the same time, we’ll build something that works on test data and breaks in production.”

Sam winces. She remembers the 200 duplicate emails. She remembers the $30,000 in shelfware. And now she remembers the transposed Golden and Dark cases, the ones she created with her own hands because she couldn’t let go.

“Fine,” she says. “One at a time.”

Oscar starts work on the shipping notification automation. It’s a simple trigger: when a shipping label is created in the carrier system, the tracking number gets captured and emailed to the customer automatically. It’s a $200-level automation that MapleCo has been paying humans to do manually for years.

It goes live in four days. It works perfectly. Henderson’s procurement manager sends Sam an email she’s never received before: “Hey Sam, whatever you changed with your shipping notifications, keep doing it. We’re getting tracking numbers within minutes now. Impressive.”

Sam screenshots that email and pins it above her desk.

But the real trouble is building in the background.

The PO system catches the problems that enter through the front door. It validates data, checks pricing, flags exceptions. What it doesn’t do, what no automation can do, is govern how people behave.

Jordan has been using the PO system’s success as motivation to experiment more. He’s not building Zapier zaps this time. He learned that lesson. Instead, he’s been using ChatGPT to build small productivity tools for himself. A prompt that summarizes customer emails. A template that drafts supplier follow-up messages. A script that converts Henderson’s CSV remittance files into a format Lisa can reconcile faster.

Some of these are genuinely helpful. The problem is what Jordan is feeding into ChatGPT to make them work.

Customer names. Order quantities. Pricing data. Contract terms. Henderson’s product mix, which is arguably competitive intelligence. Lisa’s bank reconciliation notes, which contain payment amounts and bank account references.

Jordan isn’t being malicious. He’s being efficient. He’s doing exactly what millions of employees are doing right now at companies around the world: taking business data and pasting it into a consumer AI tool because it makes their job easier. He wants to matter. He wants to contribute something real. And this, to him, feels like contribution.

Sam doesn’t know this is happening. She has no AI policy. She has no guidelines for what data can and can’t be shared with external tools. She doesn’t even know the question to ask.

Meanwhile, the Henderson’s 90-day clock is still ticking. Sam’s been so focused on the PO wins that she forgot the bigger picture. Henderson’s wants reliability across the board: orders, shipping, invoicing, communication. Sam has fixed one piece. The rest is still held together with spreadsheets and hope.

And Oscar? Oscar knows all of this is coming. He’s seen it at every client. The first win creates confidence. Confidence creates speed. Speed without governance creates the conditions for something to go very wrong.

He hasn’t mentioned it yet. Not because he doesn’t see it, but because, and this is something Sam will eventually appreciate, Oscar knows that some lessons only land when the student is ready to hear them.

That readiness is about three weeks away.