Automate Vendor Contract Comparison and Renewal Tracking with AI

The Problem

A 40-person e-commerce company uses 28 SaaS vendors — cloud hosting, email marketing, payment processing, monitoring, analytics, the works. Each contract has different renewal dates, auto-renewal clauses, price escalation terms, and cancellation windows. Last quarter, the team missed a 30-day cancellation window on a monitoring tool they had already replaced, costing them $14,000 for a year nobody needed.

The worst part isn't the money — it's the blindness. Nobody has a consolidated view of what's renewing when, which contracts have predatory terms, or where there's room to negotiate. The contracts live in a shared Drive folder, a mix of PDFs, Word docs, and email confirmations. Some were signed by people who no longer work there. One contract was found only as a forwarded email chain with the subject line "Re: Re: Fwd: agreement."

The Solution

Using the contract-review, pdf-analyzer, and report-generator skills, the workflow extracts structured terms from every vendor agreement regardless of format, builds side-by-side comparisons of competing vendors with specific recommendations, and generates a renewal calendar with escalating alerts — so cancellation windows never slip by unnoticed again.

The entire process — from a folder of messy contract files to a structured renewal calendar with alerts — takes about an hour for the initial setup and runs automatically after that.

Step-by-Step Walkthrough

Step 1: Extract Terms from Every Contract

The first step is turning a messy folder of heterogeneous documents into structured, comparable data. Point the agent at the contracts folder:

Analyze all vendor contracts in ./contracts/ — extract vendor name, contract value, start date, end date, auto-renewal clause, cancellation notice period, price escalation terms, and SLA guarantees from each document.

The parser handles PDFs, Word documents, and email-based agreements regardless of format or structure, pulling each one into a structured row with consistent fields:

• 22 PDFs parsed successfully (including scanned contracts run through OCR)
• 4 Word documents parsed (two were actually .docx files with .doc extensions)
• 2 email-based agreements extracted (one was a forwarded chain three levels deep)

The immediate findings are telling:

• 19 of 28 contracts have auto-renewal clauses
• 6 contracts renew in the next 90 days
• 3 contracts include annual price escalation above 5%
• 4 contracts have cancellation windows under 30 days
• 2 contracts have price escalation clauses buried in addendum documents (not the main agreement)

That means two-thirds of the vendor stack will silently renew unless someone actively cancels — and three of them get more expensive every year whether or not the company negotiates. The four contracts with sub-30-day cancellation windows are the most dangerous: by the time someone notices, the window has already closed.

The hidden price escalation clauses are revealing. One vendor's main agreement says "$2,800/month" but an addendum signed six months later includes a 5% annual escalation. Without parsing every attachment and addendum, that escalation is invisible until the invoice arrives.

Here's what the extracted data looks like for each contract — a single row of structured fields that can be compared, sorted, and alerted on:

Step 2: Compare Competing Vendors Side by Side

With structured data from every contract, comparisons that used to require opening three PDFs in separate tabs and manually building a spreadsheet become a single query:

The company pays three different cloud hosting vendors because each team chose their own provider two years ago. Now the contracts are up for evaluation — should they consolidate?

Create a side-by-side comparison of our three cloud hosting vendors: their pricing tiers, SLA uptime guarantees, support response times, and data residency terms. Highlight which vendor offers the best value for our usage level of 50TB bandwidth and 99.9% uptime requirement.

The comparison lands clean:

Vendor B meets the 99.9% uptime requirement at the lowest cost with no annual price escalation. But if EU data residency is non-negotiable, Vendor A is $400/month more and includes it. Vendor C is overpriced unless the team needs 99.99% SLA for compliance reasons — a $9,600/year premium for an extra nine of availability, plus a 5% annual escalation that compounds year over year. At that escalation rate, Vendor C will cost $4,600 more than Vendor A within three years.

The SLA credit terms reveal something less obvious: Vendor B's 25% credit triggers at 99.5%, while Vendor A's 10% credit triggers at 99.9%. If both vendors hit 99.8% uptime in a bad month, Vendor B pays back $700 while Vendor A pays nothing — because 99.8% is above Vendor A's credit threshold. The headline SLA numbers don't tell the whole story.

This is the kind of analysis that normally takes half a day of reading contract PDFs and building comparison spreadsheets. With structured data already extracted, it takes seconds.

Step 3: Build the Renewal Calendar

The comparison is useful for point-in-time decisions, but the real value is never missing a deadline again:

Create a renewal calendar for all 28 contracts. For each, show the renewal date, the last date to cancel without penalty, and the estimated annual cost. Sort by urgency — closest deadlines first. Export as a CSV I can import into our project management tool.

The calendar surfaces deadlines that were previously invisible:

Exported to vendor_renewal_calendar.csv, ready to import into Linear or Asana as tickets with deadlines. The DataDog alternative — the one they already replaced — has a cancel-by date just weeks away. Without this calendar, that's another $8,400 down the drain.

The calendar also reveals a clustering problem: 8 contracts renew in April, creating a rush of decisions in a single month. Knowing this in advance lets the team stagger evaluations — start the April renewals in January instead of scrambling in March.

Step 4: Set Up Escalating Renewal Alerts

A calendar in a CSV is only useful if someone opens it. The DataDog alternative has a cancel-by date in two weeks — if that CSV sits in Downloads for three weeks, the company pays another $8,400 for nothing. The final step creates a three-stage alert system that makes it impossible to miss a window:

Create a recurring reminder system: 90 days before each renewal, generate a summary of the contract terms, current market alternatives, and a recommendation to renew, renegotiate, or cancel. Include the last date to act without penalty.

Each contract gets three alerts:

• 90-day alert: Full contract summary with current market comparison and a recommendation (renew / renegotiate / cancel). Includes competitive pricing data for negotiation leverage.
• 60-day alert: Reminder if no action taken, with updated market pricing and a note about the approaching deadline.
• 30-day alert: Final warning with the cancellation deadline highlighted. At this point, the recommendation becomes a decision that needs to happen this week.

Every alert includes current spend, alternative vendor pricing, and specific negotiation leverage points — like the fact that Vendor A's competitor just dropped prices 20%, or that the team's usage has grown beyond the current tier and the next tier is actually cheaper per-unit from a different vendor.

The 90/60/30 cadence gives the team time to evaluate, negotiate, and act. At 90 days, there's time to run a competitive evaluation. At 60 days, there's time to negotiate with the current vendor using competitive quotes. At 30 days, the decision needs to be made. No more discovering a renewal three days before the cancellation window closes and panic-approving a contract nobody reviewed.

Real-World Example

Soren, the operations lead at the 40-person e-commerce company, is tasked with cutting SaaS spend by 15% before next fiscal year. The CEO wants a plan in two weeks. Soren drops all 28 vendor contracts into a folder and kicks off the extraction.

The extraction finishes in 20 minutes. The agent immediately surfaces two urgent problems: a $12,000 CI/CD contract auto-renews in three weeks (the team switched to GitHub Actions six months ago — the migration happened so smoothly that nobody remembered to cancel the old vendor), and a monitoring tool they already replaced is set to renew for $8,400. That's $20,400 in savings just from contracts that should have been cancelled months ago.

Then the comparison reveals three overlapping analytics tools — the company somehow ended up paying for all three after a trial period that nobody cancelled. One team uses Tool A, another uses Tool B, and Tool C was an experiment that became a line item nobody questioned. Consolidating to one saves $22,000 annually.

Soren imports the renewal calendar into Linear, creating tickets with deadlines for each cancellation window. Over the next quarter, the team cancels 4 redundant tools and renegotiates 2 contracts using the market comparison data as leverage — showing the vendor that a competitor offers equivalent service for 25% less. Total savings: $41,000 annually, well above the 15% target. Soren presents the plan to the CEO in week one — three days ahead of the two-week deadline — with a projected savings timeline and a renewal calendar that extends 12 months out.

And now every future renewal gets flagged 90 days in advance. The next operations lead who inherits this vendor stack won't discover a missed cancellation window after the fact — the alert system catches it three months before it happens.