Playbook: Build a Contract Renewal Tracker

Contract renewals sneak up on you. A vendor contract auto-renews in 14 days. Somebody finds out because someone else happened to mention it in a meeting. The team scrambles to decide whether to renew, renegotiate, or cancel — a decision that should have started 90 days ago.

The contracts themselves live in a shared drive. The renewal dates live in somebody's calendar. The terms live in the contracts (which nobody reads until the last minute). The history of what changed and who signed off lives in email threads that get harder to find every month.

This playbook walks you through building a contract tracker — a sandcastle that centralizes contract metadata, shows a renewal calendar, flags upcoming deadlines, and uses a subagent to send reminders well before anyone needs to scramble.

What you will build

  • A Contract Tracker sandcastle with four views: a renewal calendar, a contracts table, a detail page per contract, and an alerts dashboard.
  • Collections for contracts (master metadata), amendments (change history), and reminders (scheduled alerts).
  • A linked subagent that checks for upcoming renewals daily and posts reminders to Slack.

What you need before you start

  • An Assist workspace with access to the AI chat.
  • A list of your active contracts. At minimum: vendor name, contract type, start date, end date or renewal date, auto-renew (yes/no), annual value, and the owner (who on your team is responsible). If you have this in a spreadsheet, bring it — you will seed the collection with it.
  • The Slack bot in the channel where your procurement or legal team coordinates (e.g., #procurement-ops or #legal).

Step 1: Describe the app

"Build me a sandcastle called 'Contract Tracker'. It centralizes contract metadata and flags upcoming renewals.

Collections:

  • contracts: vendor_name, contract_type (SaaS/Services/Materials/Lease/Other), description, owner_name, owner_email, start_date, end_date, auto_renew (boolean), notice_period_days (how many days before end_date we need to act), annual_value, payment_terms, status (active/expired/cancelled/under_review), document_url (link to the contract file), notes.
  • amendments: contract_id, amendment_date, description, changed_by, document_url.
  • reminders: contract_id, vendor_name, due_date, reminder_type (90_day/60_day/30_day/7_day/overdue), sent_at, acknowledged (boolean).

Views:

  1. Renewal calendar — a month-by-month calendar view. Each contract's end_date appears as an event. Color-code: red if within 30 days, yellow if within 60, green otherwise. Click an event to go to the detail page.
  2. Contracts table — all contracts with sortable columns. Filterable by status, contract_type, and owner. A 'Renewals due' counter at the top showing how many contracts renew in the next 90 days.
  3. Contract detail — full metadata, amendment history (newest first), reminder history, and action buttons: 'Mark as Under Review', 'Mark as Renewed', 'Mark as Cancelled'.
  4. Alerts dashboard — all unacknowledged reminders, sorted by due_date (soonest first). Each row shows vendor, due date, reminder type, and an 'Acknowledge' button.

Seed with 20 contracts: mix of active (most), under_review (a few), and expired (a few). Spread end_dates across the next 6 months. Seed 5 amendments on different contracts. Generate reminders for anything due in the next 90 days."

Step 2: Review, scaffold, iterate

Review the plan. Check:

  • Does the calendar show the right months? It should default to the current month with forward/back navigation.
  • Are the color thresholds right? 30/60/90 days is common; adjust if your team needs longer lead times.
  • Does the "Renewals due" counter on the table view count correctly?

Scaffold and preview. Common refinements:

"On the calendar, show the annual_value next to the vendor name on each event. I want to see at a glance which renewals are high-value."

"Add a 'Days until renewal' column to the contracts table, calculated from today to end_date. Sort by it by default."

"On the detail page, add a 'Renewal Decision' section with radio buttons: Renew, Renegotiate, Cancel, Undecided. Save the choice to the contract record."

Step 3: Load your real contracts

If you have a spreadsheet, convert it to JSON (or paste the rows into the AI chat) and seed the contracts collection:

"Insert these contracts into the contracts collection: [paste data]."

For large lists (50+), use the Data page to create documents in batches, or ask the AI to insert them in chunks.

Step 4: Set up daily reminders

Open a chat with the linked subagent:

"Every weekday at 8 AM Eastern, check the contracts collection for:

  1. Any active contract where end_date is exactly 90 days from today and no 90_day reminder exists. Insert a reminder and post to #procurement-ops: 'Contract renewal in 90 days: [vendor_name] ([contract_type], $[annual_value]/yr). Owner: [owner_name]. Decision needed by [end_date minus notice_period_days].'
  2. Same for 60 days, 30 days, and 7 days.
  3. Any active contract where end_date is today or in the past and status is still 'active'. Insert an 'overdue' reminder and post: 'OVERDUE: [vendor_name] contract expired on [end_date] with no action taken. @[owner_name] please update.'

Call the trigger 'Daily Renewal Check'."

The team now gets Slack reminders at each milestone. Nobody has to remember to check a calendar.

Step 5: Add a weekly summary

"Every Monday at 8:30 AM Eastern, post a summary to #procurement-ops:

  • Contracts expiring this month: [count], total annual value: $[sum].
  • Contracts expiring next month: [count], total annual value: $[sum].
  • Contracts currently under review: [count].
  • Unacknowledged reminders: [count].

Call the trigger 'Weekly Contract Summary'."

This gives the team a standing agenda item for their Monday morning sync.

Step 6: Share and assign

Grant Execute access to the procurement and legal teams. Each contract owner sees all contracts but primarily acts on their own. Grant Edit to whoever will maintain the tracker long-term.

Tell each contract owner: "Your contracts are in the tracker. When you get a Slack reminder, open the detail page, make your renewal decision, and add a note. When the decision is final, update the status."

What you built

You have a contract renewal tracker that:

  • Puts every contract's renewal date, value, and ownership in one place.
  • Sends reminders at 90, 60, 30, and 7 days — and escalates when a contract expires without action.
  • Gives the team a calendar view so they can see what's coming and plan accordingly.
  • Tracks amendments and decisions on each contract's detail page, creating an audit trail.
  • Updates itself daily without anyone having to check a spreadsheet or set a personal calendar reminder.

What used to be a scramble when someone remembered a renewal date is now a managed process with 90 days of lead time.

Where to go from here

  • Cost optimization. Add a spend_history collection and a view that shows actual spend versus contract value per vendor. Use it to identify contracts you're paying for but underutilizing.
  • Approval workflow. When an owner clicks "Renew" or "Renegotiate", have the subagent create a requisition in the Purchase Approval Tracker for budget sign-off.
  • Document storage. If your team stores contracts as PDFs, add document_url links to each contract record. The app becomes the index; the documents stay wherever they live today.
  • Multi-entity. Add an entity or subsidiary field and a consolidated view across the whole organization.

Related guides