Sort your contracts before you send them

Here is a problem most procurement teams recognise and almost none of them log as a problem, because it hides inside a task that feels finished. You drag a folder of renewals into intake. The upload runs on contact. Two of the files were misnamed by a legal assistant six months ago, so a Salesforce order form has filed itself under Adobe, and a NetSuite amendment has attached itself to the wrong parent record. You do not learn this until the read has already run, extracted terms, and stamped the wrong vendor across a record that now needs unpicking one file at a time. The work was not the upload. The work was the cleanup after the upload, and the cleanup was invisible until it was yours.

The named problem: intake that commits before you look

Call it upload on contact. The old behaviour treated the moment a file touched the window as consent to process it. That is fine when every file is correct, correctly named, and correctly the kind of thing you meant to send. It is expensive the rest of the time, because a wrong file that has already been read is more work to remove than a wrong file you never sent. You are not deleting a row. You are reversing an extraction, correcting a vendor association, and hoping nothing downstream already picked up the bad record. We wrote about the read itself in Every upload gets the two minute read. The read is good. Running it on the wrong pile is not.

The fix is a pause you control. Contracts now land in a staging folder first, organised as one folder per vendor. You drag papers between folders, make a folder, rename it, take anything out of the run entirely, and nothing leaves your machine until you press Upload. The intake window stopped being a trigger and became a workbench.

Files are checked as they stage, not after they fail

Staging is only useful if it tells you the truth while you build. So the check runs on entry. A photograph of a contract, the phone snapshot someone took of a signed page, is refused in the list with its reason rather than accepted now and failed halfway through the run. Anything over 25 MB is refused the same way, in place, before you have committed to it. You see the rejection next to the file, with the reason attached, so you can swap in the real document or drop the file and keep moving. The point is that a bad file never earns a place in the run and then quietly wastes it. If your estate holds papers that read poorly as images, our note on research papers now reading as styled pages explains why the format matters as much as the content.

The run tells you its own shape as you build it

As you stage, the run states three things and keeps them current: how many papers are in it, how much they weigh altogether, and how many vendors they span. This is not decoration. It is the number you check before you commit. If you meant to send twelve renewals across four vendors and the run says fourteen papers across six vendors, you have caught two strays and two vendors you did not intend to touch, before the read runs, while correcting them is a drag and not an unpick. It is the same discipline we apply once contracts are inside the platform, where the Explorer lets you browse your estate like a file library. Getting the shelf right at intake means the library it feeds stays honest.

Where this fits your existing workflow

Staging sits at the front of intake and changes nothing after it. If you already route contracts through a watched folder on the desktop, described in give the Desk a folder and it files what lands there, staging is the manual counterpart for the runs you assemble by hand rather than by dropping into a monitored directory. The reads, the decode, the review tables, and the benchmarking downstream are unchanged. What changes is only the confidence with which they start. A clean run in produces a clean record out, and the correction work that used to live after the upload now lives before it, where it is a drag and a glance rather than an unpick.

Honest limits

Be clear about what staging does not do. It does not tell you that a file is filed under the wrong vendor. It gives you the tools to fix that in seconds, but the judgement is still yours. If you drag a NetSuite amendment into the Adobe folder by hand, staging will accept it, weigh it, count it, and run it exactly as instructed. The check is a format and size gate, not a content classifier. It refuses a photograph and a file over 25 MB. It does not read the document to decide whether it belongs where you put it.

It also does not remove the need to know your own estate. The running totals are only as useful as your expectation of them. If you do not know that this batch should be twelve papers across four vendors, the count of fourteen across six tells you nothing. Staging rewards the buyer who arrives with an intended shape and checks the run against it. And the 25 MB ceiling is a real ceiling. A genuinely large master agreement with heavy exhibits will be refused, and the answer is to split or compress it, not to expect the gate to bend. Staging makes the front of intake honest. It does not make the rest of the discipline optional, and it works best for a team that already treats its rights and records as something worth keeping clean.

Want to be updated when major licensing and pricing changes land? One analyst brief a week: the price rises, metric changes and audit campaigns that move software costs. Work email only.