S01E34: Every Call Adds a Promise. Only Some Reach the Contract.

Lets begin

I told a buyer we could port and host their existing numbers.

That was partially true. We could 100% do that… for an upcharge.

The standard was to give the customer new numbers and set up forwarding. Porting was a paid add-on, and I didn't know it was a paid add-on when I said it. I said it on a recorded call, to somebody who had no reason to second guess anything I was saying.

I was new there. Not new to selling, new to that company, which is a different thing and a worse one. I knew how to run the call. I didn't know where we drew the line on implementation, meaning what we did for the customer and what we asked the customer to do themselves. Nobody sits you down for that part. You get the deck, you get a demo environment, you get a competitor battlecard, and then you get put on calls.

So when the buyer asked what onboarding looked like, I answered. What I described was mostly what onboarding had looked like at my last company, because that was the only version of onboarding I'd ever seen.

I went to the implementation team and asked them to absorb it. It was small, and they did. The customer never knew there'd been a problem, because on their side there never was one. The whole thing started and ended inside our own building.

That's the part worth sitting with. Nothing went wrong. Nobody escalated, nobody churned, the deal closed. A promise I didn't know I was making got quietly paid for by a team that never agreed to make it, and the only reason it was fine is that it was cheap.

It’s not always going to be a cheap and/or easy fix though.

Last week I wrote that your own words aren't evidence when you're building the buyer's record. That's still true. It cuts the other way too, because your own words are the one thing in the deal you are personally on the hook for.

Your contract records whatever somebody remembered to write down. Your calls recorded all of it. What follows is the thirty minutes I run before contract goes out, and the ledger it leaves behind.

Why Promises Go Missing

They don't go missing because you were careless. They go missing for two reasons, and neither one feels like anything at the time.

The first is what I just described, and it's the one nobody warns you about. You say something that was true at your last company, or true in the demo environment, or true of the one account where somebody made an exception two years ago. It doesn't land in your own head as a commitment, because in your head you're describing how a thing works. You're being helpful. The buyer isn't hearing a description. The buyer is hearing the company, because as far as they're concerned you are the company, and anything you say about what happens after signature is now a thing they expect to happen.

The second one is slower, and it happens to people who know the product cold.

A concession you make on call two to keep momentum is invisible by call five. Nothing carries it forward. There's no field for it, and the note you wrote afterward compressed it into "discussed timeline" because at the time it genuinely was a small thing. Six weeks later somebody drafts the order form off the CRM, the notes, and their memory of the last conversation. By then the only place that promise still exists is a recording nobody is ever going to play again.

Different causes, same ending. The contract gets written from what somebody remembered, and nobody remembers everything.

Every Call Adds a Promise. Only Some Reach the contract.

The recordings already have all of them. You've just never gone and looked.

Step 1: Pull Every Promise, With the Quote Attached

Pick one open deal with contract coming in the next thirty days. One. Not the pipeline, and not the deal you're most worried about. Just one where the contract is close enough that changing it is still easy.

Quick definition, because I get asked: the contract is the order form and the SOW, the documents your buyer's procurement team actually reads. If you're early enough that it's still a proposal, use the proposal.

Pull the transcripts for every call on that deal and run this:

You are reading sales call transcripts for one deal. The buying company is [COMPANY]. Every speaker who is not from [COMPANY] is on the selling side, including any speaker you cannot identify. Find every statement where the selling side said we would do something, provide something, include something, or make something available. Return one row per statement:
- the sentence, word for word, no paraphrase
- who said it
- which call, and the timestamp
- the condition attached, if there was one, word for word Rules:
- If you cannot produce the exact sentence, leave the row out.
- Do not include questions, and do not include things the buyer asked for that nobody answered.
- Today is [DATE]. Resolve every relative date such as "end of next month" or "in two weeks" against it, and show both the original phrase and the resolved date.

The output is long and boring, and it should be. You're not looking for insight yet. You're looking for coverage, and coverage is the part you can't do from memory. That's the whole reason you're handing it to a machine.

Step 2: Sort the Piles and Flag What Needs to Live on the Contract

Now put that list next to the draft order form.

Here is the promise list from the last step, and here is the current order form, proposal or SOW. Sort every promise into one of three:
- CONTRACTUAL: the contract says this, in words that would hold up
- OPERATIONAL: a standard process covers it, but it is not written down
- IMPLIED: nothing on the contract covers this For each row add a column, ON THE contract, yes or no. Quote the clause when yes. Then list only the IMPLIED rows on their own, with their original quotes attached.

That last list is the exercise. Everything before it was setup.

On my deal, "we can port and host your existing numbers" would have been sitting in it with a timestamp on it, two weeks before anybody found out the hard way. It wouldn't have been a crisis. It would have been a line item and a two-minute conversation.

Step 3: Price the Orphans or Kill Them

An orphan is a promise your buyer heard and your contract doesn't carry. Every one of them has three possible endings, and you're choosing between them now instead of finding out in month three which one you got.

Here are the promises on my deal that appear nowhere on the contract. For each one, give me three options and pick one:
- PRICE IT: what it should cost, and the sentence I say to add it
- SCOPE IT: the narrower version we can actually deliver, and the sentence I say to reset expectations
- WITHDRAW IT: the sentence I say to take it back without it reading as a walk-back Write every sentence the way a person talks on a call. Assume the buyer heard the original promise and remembers it. Flag any promise where withdrawing it would put the deal at risk.

You won't use all three. Expect one or two things worth pricing, one worth narrowing, and a handful that were always fine and never needed a decision. That's a good result. The bad result is the one where the promise stands, nobody prices it, and somebody absorbs it quietly the way my implementation team did.

Why This Works

Every row carries the sentence and the point in the recording it came from, so the ledger is checkable instead of trusted. You can go listen. That's also what stops the model inventing things. A promise that can't produce its own quote doesn't get a row, and if it isn't in the transcript it isn't in the ledger.

The part I got wrong is worth having. I've spent a long time getting a machine to do this reliably, and most of that time went on finding where it quietly gets it wrong. Relative dates are the worst of it. "End of next month" and "before the quarter closes" came back with confidently wrong years until I started injecting today's date into the prompt. That's why it's in step one, and why the prompt asks for the original phrase sitting next to the resolved date. A ledger that silently moves a due date is worse than no ledger, because you'll believe it.

What this doesn't do is tell you whether a promise was a good idea. It tells you that you made it, and where it currently lives. The judgement is still yours, and so is the conversation.

Rep Action this week

Every open deal past demo with contract due in the next thirty days. Count them. Then pick one.

Run the three steps on that one deal. Twenty to thirty minutes.

By Friday you'll have a number: how many promises you made that appear nowhere on the contract. Write down the number, not the list.

Then tell me what you did with them. Did you price them, or did you kill them? I honestly don't know which is more common, and the answer changes what I build next. One line back is a complete answer.

~ Jay

The free version opens the ledger once, on one deal, before the contract goes out. The three below are what you use when you want to keep it.

This week in the Vault:

The Relationship Ledger. Runs all three steps across a deal's full call history in one pass, for when you already know the sequence and just want the table.

The Renewal Backfill. For an account you already closed, it finds the promises made during the original sale so you know what is outstanding before the customer tells you.

The Giveaway Audit. Across your last five deals, what you conceded that never got priced, so you can see your own pattern instead of one deal's.

Members get every Vault drop plus the full back library. $15/mo, or $100/yr and save $80.

→ Upgrade here

Click here for the stack I’d build today: https://www.sellingwithai.vip/stack