A contract is a legal document before it's a cost figure. The cost math is only as accurate as the agreement underneath it: the right type, the right dates, the right documents attached, and the right person accountable for it. This is the layer underneath the numbers.
It's easy to treat contract management as spreadsheet work. A deal gets signed, someone extracts the price, notes the renewal date, and moves on.
But the document underneath that spreadsheet entry carries real structure. What kind of agreement is it? What paperwork proves its terms? What timeline governs it? Who owns the relationship it represents? Zluri's contract model is built to capture that structure directly, rather than reducing every agreement to a number and a date.
This piece covers the document and structural side of contract management: agreement types, the paperwork checklist behind a contract, how a stack of PDFs becomes structured records, and the timeline data that ties it all together. It's one layer of Zluri's broader spend model; for the map of how contracts connect to transactions, licenses, and renewals, see how Zluri handles SaaS spend management.
What Actually Counts as a Contract
In Zluri, Contracts are distinct from Subscriptions and Perpetuals for one specific reason: they carry fixed start and end dates. A contract has a defined term that comes up for a genuine renewal decision. A subscription continues indefinitely. A perpetual never expires.
This classification matters beyond bookkeeping neatness. It determines whether a renewal reminder should ever fire for a given agreement in the first place. Misclassify a subscription as a contract (or the reverse) and reminders fire at the wrong moments, or don't fire when they should.
The Four Agreement Types
Not every contract represents the same kind of commitment, and Zluri tracks the difference explicitly through Agreement Type:
- A Master agreement covers the foundational terms and conditions governing the overall relationship.
- A Service agreement defines the specific services and payment terms actually being exchanged.
- A SOW (Statement of Work) defines goals, deliverables, and scope for a bounded piece of work.
- A True Up captures additional services or licenses procured after the original agreement was signed.
That last type deserves particular attention. Without a True Up recorded as its own distinct entry, a mid-term expansion gets absorbed invisibly into whatever number happens to be current. A year later, nobody can reconstruct when the deal grew, or why. It's exactly this history that a renewal negotiation needs when the contract comes up for a decision.
Building a Contract Record
Setting up a new contract starts with the basics: contract name, the application it applies to (or a "not an app" designation for non-software agreements), the vendor, a primary owner with optional finance and IT owners, start and end dates (both required), and the agreement type. You also choose how cost gets amortized: across months, years, quarters, the fiscal year, or from the start date specifically.
One field in this setup does more than record information. Adding a Renewal or Cancel By date actively places the contract onto the renewal calendar and switches on the full reminder sequence tied to it; the mechanics of that sequence are covered in how Zluri handles renewal management.
The Checklist: Proving the Agreement, Not Just Recording It
A contract record isn't complete as a set of dates and a dollar figure. It needs the actual paperwork behind it.
Zluri's Checklist step lets the contract document itself get uploaded directly against the record. Document-type flags are configurable, so an organization tracks whatever paperwork genuinely proves an agreement's terms: a signed order form, a data processing addendum, a security questionnaire response. Flags can be added or removed per agreement as needed.
This is what separates a contract record from a claim. Dates and figures assert what was agreed; the checklist attaches the evidence.
Handling License Detail Inside a Contract
Beneath the contract-level basics, each license line item carries its own detail: name and description, cost per license across the applicable term, and quantity, which can be split across multiple license types within the same contract.
Cost calculation offers two approaches. Pro-rata costs only the actual duration a change was active. A fixed months, quarters, or years calculation costs the full period, regardless of how many days the change was actually in effect within it.
One specific improvement worth noting: individual license line items can now carry their own duration directly. Two entries sharing the same license name but different terms or quantities no longer need the old workaround of being split into differently-named records just to represent that difference. How these line items feed usage tracking and waste detection is the subject of how Zluri handles software license management.
Turning a Stack of PDFs Into Structured Records
For organizations bringing a backlog of existing agreements into the system, typing each one in by hand isn't realistic. Bulk Contract Upload accepts up to 10 PDF files per batch (5MB max each, English only), and Zluri's AI parses each one into a draft record.
The process is deliberately not automatic end to end. A parsed file moves through three states:
- Pending: still processing
- Review Draft: parsed and ready for a person to check
- Contract Added: confirmed by a reviewer through Add Contract
The contract doesn't exist in the live Contracts list until that review step happens. Parsing alone doesn't create it. This is a deliberate safeguard: an AI-parsed misread never quietly becomes an authoritative record without someone checking it first.
Tracking the Full Timeline of a Relationship
A single renewal date doesn't tell you much about a vendor relationship. Contract Timelines track the fuller picture over the life of an agreement: the original start date, the end date, every renewal notification as it fires, and related milestones along the way. The result is a single place to see not just when a contract ends, but the full history of touchpoints leading up to that point.
Why the Document Layer Actually Matters
Every downstream calculation (cost math, renewal timing, optimization decisions) is only as trustworthy as the document representation it's built on.
A True Up that was never recorded as its own agreement type leaves the next renewal negotiation working from an incomplete picture of how the deal grew. A contract with no checklist documentation is a claim with no evidence behind it, if a vendor dispute or an audit ever asks for proof.
Getting the structural, document-level side right is what makes everything downstream (cost tracking, renewal timing, and the transaction-level spend reconciliation it all checks against) defensible, rather than a set of numbers nobody can trace back to an underlying agreement.
Frequently Asked Questions
What's the practical difference between tracking a mid-term license addition as a True Up versus just updating the existing contract's quantity?
A True Up creates its own distinct record, preserving exactly when and what was added as a separate, traceable event. Updating a quantity in place loses that history, leaving only a current number with no record of how or when it grew. That history matters directly when the next renewal negotiation needs to reference what actually changed and when.
Does uploading a contract PDF through Bulk Contract Upload make it live immediately?
No. A parsed file sits in Review Draft status until a person reviews the extracted data and confirms it through Add Contract. Only then does it become a live record in the Contracts list. Parsing alone doesn't create the record, which is a deliberate check against an AI misread becoming authoritative and unreviewed.
Can a single contract have license line items with different durations under the same agreement?
Yes. Individual license line items can carry their own specific duration, so two entries with the same license name but different terms or quantities don't need to be split into separate, differently-named records. This is a real fix over the workaround this used to require.
What actually happens when a Renewal or Cancel By date gets added to a contract?
It does more than store a date. It places the contract onto the active renewal calendar and enables the full reminder sequence tied to it. The 30/15/7-day renewal warnings and the cancel-by sequence specifically depend on that date being set.
.svg)
