I once watched a vendor contract go through nine rounds of redlines over six weeks. Nine rounds. The final version had exactly three material changes from the first draft. The other six rounds were people on both sides editing the same clauses back and forth, losing track of what had already been agreed, and reopening issues because nobody could tell which version was current.

The deal was worth $80,000 a year. We spent more in billable hours negotiating it than the first year of the contract was worth. And the worst part? Nobody thought that was unusual. It was just how redlining worked.

It doesn’t have to work that way. But it will, every single time, if you don’t put some structure around it.

The version control problem that nobody admits is a problem

Here’s what actually happens during most contract redlines. Someone sends a Word doc. The other side makes changes with track changes on and sends it back. Your legal team reviews it, accepts some changes, rejects others, makes their own edits, and sends it back again. Somewhere around round three, someone saves the file with track changes off. Now nobody can tell what changed. Someone else opens the wrong version from an old email and starts editing that. Now there are two parallel versions floating around with different changes.

I’m not describing a worst case here. I’m describing… just about every single day of my life, before I changed the way I worked.

WorldCC’s 2024 Most Negotiated Terms research found that limitation of liability has been the number-one most negotiated contract term for over a decade, followed by pricing and indemnification. But here’s the finding that should bother everyone managing a redline process: only 16% of negotiators surveyed believed they were actually focusing on the right things during negotiations. The terms people spend the most time arguing over (liability caps, indemnification carve-outs) aren’t the terms that actually drive successful contract performance. Those would be scope, delivery terms, and service levels.

So you’ve got a process that’s already slow, that breaks down mechanically through version chaos, and that’s pointed at the wrong targets. That’s the redlining problem in three sentences.

What I learned from the nine-round disaster

After that six-week debacle, I sat down and looked at what actually went wrong. It wasn’t that either side was being unreasonable. It was that nobody had a plan. Specifically:

Nobody defined what was negotiable before the first draft went out. Our side sent a contract loaded with aggressive terms we didn’t actually care about. The vendor’s legal team dutifully redlined all of them. We spent two rounds just getting back to reasonable positions on clauses we would have conceded from the start.

Nobody kept a single source of truth. By round four, there were at least three versions of the contract in circulation. My legal team was working from one, the vendor’s counsel had another, and their procurement lead had forwarded an older version to their CFO for review. We literally had to pause the negotiation to agree on which document was the real one.

Nobody tracked what had been agreed. In round seven, the vendor’s attorney reopened a liability cap we’d already agreed to in round three. When I pointed this out, she said she had no record of that agreement. She was probably right, because we didn’t have a formal record either. Just an email thread with 47 messages.

The rules I use now

I’m not going to pretend I’ve built some elegant system. What I have is a set of rules that prevent the stupidest failure modes. They’re boring. They work.

Rule 1: Internal alignment happens before the first redline goes out. Before I send a contract to the other side (or before I start marking up theirs), I get our internal stakeholders in a room for 15 minutes. We decide: what are we willing to accept, what’s negotiable, and what’s a deal-breaker? This takes 15 minutes. It saves weeks.

This is where I’ve learned to use what I call a three-column list: accept as-is, negotiate with fallback position, and must-have. If you can’t fill in the “fallback position” column, you’re not ready to start redlining. You’re just going to argue until someone gets tired.

Rule 2: One document, one location, one version at all times. I don’t care if it lives in your CLM platform, a shared drive folder, or a carrier pigeon’s leg pouch. There is one current version and everyone knows where it is. Period. When someone sends a marked-up version back, it gets saved to the single location and the previous version gets archived (not deleted, archived). The file naming convention is: [Counterparty]_[Contract Type]v[Number][Date]. Not “FINAL.” Not “FINAL_v2.” Not “FINAL_REALLY_FINAL_USE_THIS_ONE.”

Rule 3: Every round has a summary. When I send a redlined contract back to the other side, I include a short email that says: “Here are the changes in this round. Items 1-3 are accepted from your last markup. Item 4 is a counter-proposal on [clause]. Item 5 is a new edit to [section] because [reason].” This takes five minutes to write and eliminates the “wait, what changed?” conversation that otherwise eats an entire round.

Rule 4: Agreed terms are locked. Once both sides accept language on a clause, I note it in a running tracker. If someone tries to reopen it in a later round, the tracker is the evidence that it was already settled. This doesn’t mean you can never revisit something. But it means reopening a settled term is a conscious decision, not an accident.

Rule 5: Set a round limit. For standard contracts (under $100K, routine terms), I target three rounds of external redlines. If we can’t get there in three, something is fundamentally misaligned and we need a call, not another markup. For complex deals, five rounds is my ceiling before I insist on a live negotiation session. The 2025 Contracting Benchmark Report found that SaaS contracts are negotiated 70% of the time and take an average of 40 days to execute. Forty days for a SaaS deal. Redlining without guardrails is how a contract that should close in two weeks stretches to two months.

Where the time really goes

Most people think redlining takes forever because the other side is being difficult. Sometimes that’s true. But in my experience, the bigger time sink is internal. Your own team can’t agree on what they want. Legal marks up liability. Then procurement comes back and says the pricing section needs changes too. Then someone from the business side reads the redline and has questions about the scope section that should have been resolved before the contract was drafted.

I once tracked the time on a mid-size vendor agreement. Total elapsed time from first draft to signature: 23 days. Time spent waiting for the other side: 6 days. Time spent on internal review and alignment: 14 days. Time spent on actual drafting and markup: 3 days.

The bottleneck wasn’t the negotiation. It was us.

That’s why Rule 1 exists. If you do the alignment work up front, the redlining process is just mechanics. Mark up the document, send it, review the response, repeat. Without alignment, every round is both a negotiation with the other side and an internal debate about what you actually want. No wonder it takes nine rounds.

The playbook nobody builds

The other thing that changed my redlining life was building a clause playbook. Not a clause library (though those are useful too). A playbook that says: for this type of contract, here is our starting position on liability, here is our fallback, and here is our walk-away. Same for indemnification, termination, IP ownership, and the other usual suspects.

Ironclad’s analysis of contract cycle data found that NDAs with non-standard confidentiality terms take three times longer to approve than those using standard language. That multiplier applies to every clause type. The more you standardize your starting positions and pre-approve your fallback positions, the less time every single redline takes.

My playbook is a two-page document. It covers our top eight most-negotiated clause types with three columns: our preferred language, acceptable alternatives, and deal-breakers. Anyone on my team can open it before a negotiation and know immediately what they can agree to without escalating and what requires a conversation.

It’s not glamorous. It saves us roughly one to two rounds per negotiation. At the volume we handle, that’s weeks of cumulative time back every quarter.

Let’s be honest about what redlining actually is

Here’s the thing I wish someone had told me earlier in my career: redlining is not a legal exercise. It’s a project management exercise. The legal substance (what do these clauses mean, what risk do they create) is important, obviously. But the reason redlining spirals isn’t usually bad legal judgment. It’s bad process: unclear ownership, missing version control, no internal alignment, no defined endpoints, and no record of what’s already been decided.

Every one of those is fixable without a law degree. Every one of those is fixable without new software, though a decent CLM with version history helps (I use ContractSafe for storage and tracking, but the redlining itself mostly happens in Word because that’s where lawyers live, and I learned a long time ago to stop fighting that battle).

The goal isn’t zero redlines. Negotiation is healthy. Contracts should reflect what both sides actually agreed to, not just what one side wanted. The goal is zero wasted rounds. Every exchange should move the contract closer to done. If a round doesn’t change anything material, it wasn’t a round. It was a delay.

Put some structure around it. Name your files properly. Align internally before you go external. Track what’s been agreed. Set limits. Write summaries.

It won’t make redlining fun. But it will stop making it the part of your job that eats everything else.