Most teams trial “AI for contracts” and never get past a demo. Not because the tech is weak, but because the setup is a mess: scattered folders, no review template, and nothing connecting the contract to the noise in the inbox where risks actually show up.

Here’s the playbook we use to stand up Hevi in a single session so a team can review a live tender today and start capturing delivery-phase risks tomorrow. It’s simple: structure → templates → extract → monitor → act. You’ll be live without a transformation project, and—more importantly—every output will be traceable to the clause.

1) Structure the account so people see only what they should

Most failure starts with permissions and structure. Fix that first.

User groups
Mirror your org. If you operate globally, split by region or business unit (e.g., “Global → North America / APAC / EMEA”). A user belongs to one or more groups. This keeps legal, commercial, and project teams focused on their own work.

Projects
Within each user group, create projects for either:

• Pre-Contracts (tendering) — a single “department” project with one parent folder per tender, or
• Active Contracts (delivery) — one project per awarded contract once you move to execution and site administration.

Roles

• Owner can do everything (perfect for Legal/Commercial).
• Member is view-first (great for operations who need answers but shouldn’t change templates).

This upfront structure pays off when you roll from tender to award. You move a folder—not a circus.

2) Bring order to documents (and point Hevi at the right level)

Hevi reads whatever you select in the left-hand file tree. That’s power—and a trap.

• Create the parent folder for each tender or contract: e.g., Tender – Project X or Contract – Project X.
• Use subfolders for clarity: Contracts, Schedules, Scopes, Specs, Appendices.
• Upload at the right level: If you ask a question at the parent folder, Hevi considers all subfolders. If you only want the head contract, select the Contracts subfolder first.

That single habit—selecting the correct folder before you ask—is the difference between fast and fuzzy.

3) Build your “gold standard” review once (with CSV), reuse forever

Document prompts are fine for exploration. For repeatable, defensible reviews and tender analyses, use a CSV template.

Why CSV beats ad-hoc prompts

• Completeness: You never forget a critical clause.
• Consistency: Every reviewer uses the same wording and thresholds.
• Comparability: You can compare answers across tenders and contracts.

What goes in the CSV

• Question/Policy (plain English): “What is the delay notice period and required contents?”
• Risk Lens: High/Medium/Low or Commercial/Legal/Safety.
• Preferred Position (your house rule): “≥10 business days; notice must include cause, impact, mitigation.”
• Tolerances (if applicable): numbers and ranges you accept.
• Output Columns you want populated (e.g., Clause Ref, Answer, Risk, Implication, Proposed Position, Next Step).

Upload this CSV as a shared template for the user group. Now anyone can run a first-pass review that citations each answer, populates your exact columns, and is ready to export.

Tip: Use the chat to fine-tune the wording of tricky questions, then lock it into the CSV when it reliably returns the outputs you want.

4) Run your first review: hours, not weeks

With the CSV ready and documents in place, run the contract or tender review:

1. Select the correct folder (usually the parent tender or the Contracts subfolder).
2. Start Review → Choose your CSV template.
3. Hevi answers each policy item, returns clause references with clickable links, and fills your columns.
4. You edit the outliers (judgment lives with humans).
5. Export to Excel or keep it in Hevi as your departures backbone.

You now have a structured, clause-linked view of the contract and the beginnings of a defensible departures table. If a client needs their own format, you can transform your outputs in chat by instructing Hevi with their exact column headers and required language.

5) Move from “review” to “admin”: extract workflows with AI

Once a contract moves to delivery, the game changes: time bars, procedures, triggers. Manually mapping processes is where good intentions die. Use Extract Workflows with AI:

• Hevi scans the executed contract and builds flowcharts for core processes (e.g., production relief events, variations, EOTs, extensions/options, KPI reviews).
• Each step includes the deadline (e.g., “Notice within 5 business days”) and a clause link.
• You can edit step names, add sub-steps, and adjust timing inside the visual flow.

Now you have live, contract-specific procedures your team will actually follow—because they’re one click from the source clause.

6) Where the money is: wire the Email Monitor

Claims are won or lost in the inbox, not in a binder. Connect a project email (e.g., projectX@yourco) or forward in project traffic:

• Hevi reads incoming emails and reports against the contract.
• It flags risks (e.g., equipment downtime, access issues, scope changes, KPI shortfalls) and shows the clause, implication, and recommended next step.
• Nothing auto-sends—a human approves or dismisses each draft. That single guardrail preserves speed without creating new risk.

Start simple. Let Hevi run for a week to see what it calls High/Medium/Low risk. Tune thresholds only if you need to reduce noise. The goal is a steady feed of clause-linked, actionable signals—not an alert firehose.

7) Turn workflows into cases (with deadlines you’ll actually meet)

When the Email Monitor or a supervisor spots a trigger, you want a clean path to action:

• Create a Case from any extracted workflow (e.g., PRD-1 Production Relief Event).
• Hevi sets the current step and calculates the deadline (e.g., “5 business days → due 20 Oct”).
• Assignees get email reminders before it bites.
• Every step retains the clause link for quick verification.

This is how frontline teams stop missing time bars without having to read a 200-page contract—they see the clause and the next step, in context, on time.

8) Don’t forget the “soft stuff”: key dates and recurring obligations

Not everything is a formal workflow. Many contracts hide soft obligations that cost real money when ignored (e.g., quarterly KPI reviews, stakeholder councils, audit windows, option notices).

Use Key Dates to track these:

• Ask Hevi in chat: “List all recurring obligations and key review meetings in this contract.”
• Create tasks with owners, recurrence, and supporting documents.
• Roll them up on the portfolio dashboard to see what’s coming across all projects.

Even a handful of well-chosen key dates (KPI reviews, options to extend, audit gates) can save a contract.

9) Compare V1…V4 without losing the plot

Negotiations produce versions. Delivery inherits confusion. Keep the thread:

• Store V1, V2, V3 in separate folders or replace the doc and rerun the review—Hevi keeps version history.
• Use Compare Documents in chat to highlight material changes, then ask: “Summarise how these changes increase the contractor’s risk exposure in three sentences.”
• At award, run Base vs Executed to produce a material changes handover for the site team.

You hand over truth, not folklore.

10) Operating norms that make AI trustworthy

A few simple rules turn Hevi from “pilot” into “how we work”:

1. No answer without a clause link. If it can’t show the source, it doesn’t ship.
2. No auto-send. A human approves anything external.
3. One table of truth. Departures live in Hevi; exports are downstream views.
4. Review cadence. Commercial/legal review the CSV template quarterly to capture lessons.
5. Stateless by design. Hevi doesn’t “learn” your data between sessions; it stays inside the four walls of each run (safer for enterprise). The underlying models improve over time, but your data isn’t the training set.

The 30-Minute Stand-Up Checklist

Pre-Contracts (Tender)

• Create/confirm user group and project
• Upload tender pack under a single parent folder
• Load your CSV review template and run the review
• Export clause-linked outputs and draft your departures in the client’s format (via chat transform)
• Use Compare if you have previous versions/contracts with the same client

Active Contract (Delivery)

• Upload/select executed contract as main doc
• Extract Workflows and review deadlines/steps
• Wire the Email Monitor; let it run for a week
• Create first Case from a likely workflow (e.g., delays/EOT)
• Add Key Dates for KPI reviews, options, councils
• Share a Material Changes summary with the site team

You’ll feel value within a day: a clause-linked review, live workflows, inbox-driven risk flags, and real deadlines.

Why this approach wins

• Speed with proof. Outputs are fast and defensible because every answer is anchored to a clause link.
• Less change management. Teams don’t have to become contract experts; they follow steps with linked sources.
• Fewer misses. Time bars, KPI dips, and scope creep emerge from the inbox in time to act.
• Cleaner handovers. Negotiation context survives into delivery.
• Scales by structure. User groups, templates, and cases keep complexity manageable as you grow.

If you want to pilot this on a live contract, bring one. We’ll stand up the structure, run a clause-linked review, extract workflows, and show the Email Monitor flag a real risk—all in a single working session.

Clause. Link. Action. Human decides. That’s how AI becomes a contract advantage, not a liability.

‍