Steve Pritchard recently shared something that caught my attention: "Yesterday's newsletter landed and it's the most detailed one I've put out." He then laid out two ideas that belong in the same conversation: a quote-to-cash reconciliation agent that recovered "$408K in annual revenue" for a staffing firm, and a hard look at the "invisible copy-paste labour" hiding inside a typical SaaS stack.

That pairing is the point. Lost revenue and wasted labor are often symptoms of the same thing: the gaps between systems, handoffs, and decision points where data changes hands without a reliable source of truth.

The real enemy is not your tools - it is the handoffs

Pritchard’s post emphasizes something many teams feel but rarely measure: the cost of work that is not clearly owned by any one tool.

When your process spans CPQ, CRM, billing, support, spreadsheets, and inbox approvals, the biggest risks do not come from one system being bad. They come from transitions:

Someone retypes a quote line into a different form.
A discount rule is applied in one place but not another.
A contract amendment updates one field but not the downstream invoice.
A unique customer identifier is inconsistent across tools.

Each handoff becomes a mini decision: "Is this the latest version?" "Do these totals match?" "Did we already bill this?" If there is no explicit checkpoint, those decisions happen implicitly, and quietly.

Key idea I took from Steve Pritchard: mapping "every handoff, every decision point, every place the data moves" is the fastest way to find both revenue leakage and labor waste.

What a Quote-to-Cash reconciliation agent actually does

Quote-to-cash (Q2C) is the chain from pricing and quoting to contracts, fulfillment, invoicing, and revenue recognition. In theory it is linear. In reality it branches constantly: revisions, renewals, add-ons, partial fills, refunds, credits, and manual exceptions.

Pritchard mentioned a "full five-stage architecture, from Quote Extractor to Human Checkpoint." That detail matters because reconciliation is not just "use AI." It is a workflow that:

Pulls data from multiple sources
Normalizes it into a comparable format
Detects mismatches
Proposes fixes
Escalates uncertainty to a human

A practical five-stage architecture (expanded)

Here is what that architecture often looks like when you turn it into an agent-based system.

1) Quote Extractor

Goal: reliably capture quote data (line items, terms, discounts, dates, customer identifiers) from wherever it lives.

Inputs can include:

CPQ exports
CRM opportunities
PDFs sent to customers
Email threads that contain the "real" terms

The critical design choice: extraction must be deterministic where possible (APIs, structured exports), and AI-assisted only where needed (PDF parsing, email summarization).

2) Order and Invoice Mapper

Goal: connect the quote to the downstream records (order, invoice, subscription, timesheet, fulfillment ticket).

This is where many teams fail, because keys do not match. A good mapper uses a hierarchy of matching signals:

Exact IDs when available
Customer + date + amount proximity
Line-item fingerprints (SKU + quantity + unit price)

3) Reconciliation Engine

Goal: compare what was promised vs what was delivered and billed.

This engine should generate specific, testable statements, for example:

"Quote line item A is missing from invoice."
"Invoice includes an extra line item not present on any approved quote revision."
"Discount on renewal exceeds policy threshold."

To make this safe, treat it like accounting software: clear rules, audit logs, and reproducible calculations.

4) Resolution Proposer

Goal: propose the next best action, not just flag a problem.

Examples:

Create a draft invoice adjustment.
Open a ticket to sales ops to attach the correct quote revision.
Request a customer confirmation if the mismatch is contractual.

AI is useful here as a co-pilot that suggests steps and drafts messages, but the system still needs guardrails so it cannot "fix" revenue by inventing terms.

5) Human Checkpoint

Goal: put humans only where the risk is real.

This is the part of Pritchard’s architecture I most agree with. The goal is not full automation. It is selective automation with explicit review gates:

Low-risk mismatches auto-resolve (for example, formatting or rounding).
Medium-risk mismatches require approval from RevOps.
High-risk mismatches route to legal, finance, or account owners.

The outcome is not merely fewer errors. It is faster cycle times and fewer "unknown unknowns" that turn into write-offs.

The $6,500 per month copy-paste tax is more believable than it sounds

Pritchard also wrote that "your 12 SaaS tools are probably costing you $6,500 a month in invisible copy-paste labour before you even look at the subscription fees" and that the number is "what falls out when you actually time" the work.

That is the key: time it.

A simple way to estimate the invisible labor cost

Try this back-of-the-envelope model:

List the top 10 cross-tool workflows (quote creation, contract send, invoice creation, renewal, onboarding handoff, support escalation).
For each workflow, measure:

number of handoffs
minutes per handoff
frequency per week

Multiply by fully loaded hourly cost.

Example:

6 handoffs per deal
3 minutes each (finding, copying, pasting, checking)
40 deals per month
That is 6 x 3 x 40 = 720 minutes, or 12 hours monthly for one workflow.

Now add renewals, amendments, onboarding tasks, and finance follow-ups. The number snowballs quickly, especially when multiple people repeat the same checks.

What Steve Pritchard is really pointing at: subscriptions are the obvious expense, but coordination is the hidden one.

Where AI agents fit - and where they do not

The temptation is to say: "Great, we will put an agent on it." But the Q2C example shows the right sequence:

Map the process and the data movement.
Identify the highest-leverage mismatch points.
Decide what can be automated safely.
Build checkpoints for everything else.

AI agents are best at:

Extracting and structuring messy inputs
Detecting anomalies across systems
Drafting resolutions and routing work

AI agents are risky at:

Making contractual decisions without context
Changing financial records without audit trails
"Learning" inconsistent processes instead of forcing clarity

Practical next steps if your team feels the pain

If you want to apply what Pritchard is describing, here is a pragmatic path.

1) Do a handoff inventory

Pick one core workflow and document each transfer of information. If you cannot draw it, you cannot fix it.

2) Create a mismatch taxonomy

Not all mismatches are equal. Label them:

Formatting (safe)
Timing (often safe)
Policy (needs review)
Contractual (high risk)

3) Build for observability first

Before automation, add:

unique identifiers
logging of edits
audit trails
a single place to see the "diff" between systems

4) Automate the boring checks, not the hard calls

Let the system reconcile totals, dates, and line items, then route exceptions to the right humans.

Closing thought

What I appreciate about Steve Pritchard’s post is the insistence on specifics: real revenue recovered, a named architecture, and a measurable labor number. That is the antidote to vague "AI will make us efficient" talk. When you map the handoffs and time the transfers, both revenue leakage and copy-paste labor stop being opinions. They become line items you can fix.

This blog post expands on a viral LinkedIn post by Steve Pritchard. View the original LinkedIn post →