Your Finance Team Has a Copy-Paste Budget. Nobody Approved It.

Shepherds of Data

Every finance organization runs a line item that never appears in the budget, never gets discussed at the board meeting, and never has an owner. It's the cost of moving data by hand from one system into another — reading a value off one screen and typing it into a different one. Not analysis, not judgment, not decisions. Just control, c, and v.

Daylit's mission is to automate the mundane, and from our perspective, nothing is as mundane as copying and pasting data from one system into another. This work needs to disappear.

We speak to about 100 order-to-cash professionals every month, and one theme kept coming up: copy-and-pasting notes. We started asking more questions, and quickly arrived at the conclusion that OTC workers are spending far more time than they'd like clipboarding data across the organization. So we decided to look into it.

The Research

We set out to model how much copy-and-pasting was really happening inside our customers' finance departments. To do that, we modeled an average PE-backed customer profile of ours: a $250M business services firm, 20 people in finance, 5,000 invoices a month, slow-paying customers, a high volume of disputes, and a somewhat complex AP function.

The goal was to learn how much they were paying in copy-paste every year. The results were shocking:

That's 3.3 full-time equivalents inside a 20-person team doing nothing but retyping. And nearly half of it happens in one place.

Where the Money Goes

Fully loaded labor cost at 1.3× base. Literal transcription only — excludes manual assembly and formatting, judgment work, error rework, and the cost of delayed cash.

Order-to-cash is the largest line by a wide margin. Nearly half of the copy-paste hours, and almost half the budget, is stuck in the O2C department. Our customers weren't joking.

A Sanity Check on the Number

We decided to verify our $300,000 claim, since it's a large number. We turned to ProcessMaker, a firm that runs process-intelligence software that observes how work actually happens inside enterprise applications. Their research puts the average enterprise employee at more than 1,000 copy-paste actions per week. Across a typical 20-person business operations team, they measure over 21,000 per week and more than a million a year.

Our model was built bottom-up from seats, invoice volumes, and workflow patterns — no reference to that figure at all. At roughly 23 seconds per action, 131 hours a week works out to about 20,500 copy-pastes weekly, or just over a million a year.

These two completely different methods, landing within 3% of each other, give us enough confidence to proceed. It's clear that the finance department is drowning under the copy-and-paste keys.

The Workflow That Costs the Most: Collections and Disputes

Collections and disputes is $45k a year in retyping cost. On the table above, that's already a huge number. In practice it's even more consequential, because every hour of it sits directly between an invoice and the money.

Here's what that $45k actually consists of.

Notes Retyped Into the ERP

A collector gets an email from a customer. The customer says they'll pay Thursday, but they're short-paying one invoice because of a freight discrepancy.

The collector writes that in an email to their internal contact. Then they write it again in the ERP's notes field. Then, because the ERP's notes field is a single unstructured text box that nobody can report on, they write it a third time in the shared collections spreadsheet — the one with the promise-to-pay dates, the escalation flags, and the color coding the team actually runs on.

One conversation. Three systems. Two of them exist only because the first one can't hold the information in a usable shape. This is the single most common copy-paste pattern in collections, and it's almost entirely invisible, because it looks like documentation rather than duplication.

Reason Codes Transcribed Into a System of Record

Every customer codes their deductions differently. One sends a numeric code. Another writes a sentence in the remittance. A third puts it in a portal field that doesn't export.

Your ERP has its own reason code taxonomy — probably a dozen values, probably defined years ago by someone who no longer works there. Somebody has to read what the customer sent, decide which of your dozen codes it maps to, and key it in.

That mapping decision is judgment. The keying is not. And because the mapping is done fresh every time by whoever picks up the deduction, the same customer's same deduction reason gets coded three different ways across three months — which means the deductions report that's supposed to tell you why you're losing margin tells you nothing. You're paying for the transcription twice: once in the hours, once in the analysis you can't do afterward.

Dispute Packets Assembled by Hand

A customer disputes an invoice. To resolve it, somebody needs the invoice, the PO, the proof of delivery, the signed BOL, the rate card that was in effect, and the email thread where the change was agreed.

Those live in six places: the ERP, the WMS or TMS, a shared drive, the customer's own portal, someone's inbox, and a contract folder.

Assembling the packet means opening all six, copying the relevant details into a single document or email, and sending it to whoever approves the credit. Then, when it's resolved, copying the outcome back into the ERP and closing the dispute.

For a business with a high dispute volume, this is the largest single time sink in the AR function — and the one most likely to be done by your most experienced person, because they're the only one who knows where everything lives.

Why This Line Matters More Than Its Dollar Value

Twenty hours a week of collections and disputes retyping is $45k in labor. That's real money, but it's not the number that should worry you.

The number that should worry you is what those twenty hours displace. They're twenty hours not spent on the phone. Twenty hours of calls not made, escalations not chased, disputes not resolved. And the disputes that don't get resolved don't just sit there — they age, they become uncollectable, and they get written off as credits at the end of the year.

Manual AR processes carry meaningfully longer DSO than automated ones. On $250M in revenue, a five-day DSO improvement frees roughly $3.4M in working capital.

The copy-paste budget for the entire finance organization is $300K. The impact on delayed collections due to collectors copy-pasting is far higher.

More Than Just a Headline

That's the headline. But the number understates the problem, and here's why.

Order-to-cash is staffed with a generally lower-salaried workforce within the finance org. When a function generates a lot of manual work, the natural response is to staff it cheaply — and cheap staffing is why the function never gets fixed. Each individual seat looks affordable, and it's natural to throw more team at a problem without investigating the root cause.

A slow month-end close is annoying. A slow FP&A process is frustrating. A slow order-to-cash process is a working capital problem, and on a $250M book, a few days of DSO is worth more than the entire $300K copy-paste budget several times over.

So the question isn't just where the hours go. It's where the hours turn into cash that hasn't arrived yet.

What to Do About It

1. Count it. Not a survey — sit with one collector for an hour and mark every time they type something that already exists somewhere else on their screen. You'll get a number, and the number will be higher than the estimate you'd have given.
2. Look at what's actually moving. Most of it is context one system needs and another one already has. But it's rarely a clean copy. Before that note gets pasted anywhere, someone decides what it is — an invoice dispute or a billing dispute, a short-pay or a promise-to-pay. There's a logic layer sitting between the copy and the paste.
3. Ask where that logic lives. Is it written down as a standard procedure, or is it in your senior collector's head? If it's the latter, you don't have a process — you have a person. That's a risk worth addressing on its own, before you automate anything. It's also why the function never gets fixed: you can't hand off work that was never documented, so you hire another seat instead.
4. Then ask why a human still has to do it. Once the logic is an operating procedure, it's a set of rules. AI can learn your SOPs and execute the routing — the note, the tag, the reason code, the packet — while your team spends those twenty hours on the phone instead of on the keyboard.

The hours aren't the prize. On a $250M book, five days of DSO is $3.4M. The entire copy-paste budget is $300K. You're not cutting a labor line — you're deciding how fast your cash comes home.