Contracts

Contracts is proper contract administration built for Australian builders. It’s where you set up your head contract with the client and your subcontracts with your trades, track practical completion dates, issue variations and notices, run progress claims and payment certificates, and manage retention. This guide walks each of those workflows.

This is a big module, so it’s organised by what you’re trying to do. Use the headings to jump to the bit you need.

The building blocks

• Head contract — your contract with the client for the whole project.
• Subcontract — your contract with a subcontractor for a package of work.
• Contract actions — the formal instruments you issue under a contract: variations, extensions of time, RFIs, notices, instructions, delay and defect notices.
• Progress claims — claims for payment as the work proceeds (yours to the client, or a subcontractor’s to you).
• Payment certificates — what you certify as payable against a claim.
• Retention — money held as security, and its staged release.

The Contracts dashboard brings the live picture together. Scope items sit under a contract as the priced breakdown that claims and variations work against.

Head contracts

Creating a head contract

1. Open Head contracts and Create.
2. Set the client, contract number, key dates (signed, start, end), the contract value, and the progress claim type (see below).
3. Set the commercial particulars: retention percentage, security form (cash retention, bank guarantee, insurance bond, etc.), liquidated damages rate and cap, defects liability period, jurisdiction and home warranty scheme.

You can also create a head contract from a PDF — upload an existing signed contract and CortexPM uses OCR to extract the particulars for you to review and apply, rather than keying them all in.

Practical completion (PC) date tracking

This is a CortexPM speciality. A head contract tracks four PC dates so you always know where completion really stands:

• Contract PC date — the original baseline.
• Revised contract PC date — baseline plus any approved extensions of time.
• Forecast PC date — your current best estimate.
• Actual PC date — recorded when practical completion is achieved.

Keeping these current gives owners and PMs honest visibility of whether the job is running to time, and feeds liquidated-damages and retention timing.

Progress claim type

Set how the contract is claimed when you create it — this drives how progress claims are built:

• Milestone based — claims against defined milestones (optionally from a milestone template).
• Trade breakdown — claims against the trade/scope breakdown.
• Invoice based — cost-plus / construction-management style, where each claim is built from vendor invoices in a claim period plus a margin line (see Invoice-based claims under Progress claims below).

Issuing to the client and particulars

• Submit the contract to the client to share it for review.
• Generate the contract particulars PDF — the formal contract particulars document, using your contract template and the right state licence.

Subcontracts

A subcontract is the mirror image: your contract with a trade.

1. Open Subcontracts and Create one, setting the subcontractor, value, dates and scope.
2. Build the scope items for the package — these drive the subcontractor’s claims and any variations.
3. Generate the subcontract particulars PDF to issue.

Subcontracts connect to subcontract orders in Purchasing, and to the subcontractor portal where your trades can see their scope, claims and documents (see Subcontractor Portal).

Variation flags: a subcontractor can flag a potential variation from their portal before anything formal is raised. Each flag appears against the subcontract for you to convert into a formal variation or dismiss.

Contract templates and clauses

To keep your contracts consistent, set up contract templates with a reusable bank of clauses.

• Build contract templates for the contract types you use.
• Maintain a clause library; add clauses to a template as inclusions, reorder them, toggle them on or off per contract, and edit the wording.
• Reset to defaults if you want to start a template’s clauses fresh.

These templates then drive the wording of your contract particulars documents.

Annexures and attachments

A contract is rarely just the agreement. Drawings, specifications, a scope schedule, an insurance certificate — the annexures are half the document.

The Annexures card on a head contract, a subcontract or a contract action lets you attach documents from your Documents register. Give each a label — “Architectural drawings — Rev C” — and it sits on the contract as a numbered annexure.

Each annexure has an include when issued toggle. On, and it’s sent with the contract when you issue it. Off, and it stays attached on your side without going to the other party. Useful for the things you want linked to the contract but not in the recipient’s pack.

Watch out: an annexed document can’t be deleted from Documents while it’s attached to a contract. Detach it from the contract first if it genuinely needs to go.

Contract actions take attachments the same way, so a variation can carry its own marked-up drawing.

Separable portions

Where a contract is delivered in stages, set up separable portions. Each portion can carry its own PC dates and retention, and claims, budgets and reporting can be tracked per portion. Create and manage portions from the contract, and import them onto a head contract where needed.

Contract actions (variations, EOTs, notices)

Contract actions are the formal instruments you raise under a contract. The types include Variation, Extension of Time, Allowance Adjustment, RFI, Notice, Instruction, Delay Notice and Defect Notice.

RFIs

An RFI is a contract-administration instrument first: it is raised under the contract and numbered with it (RF-HC26-0012-002), and that record is what you produce later. What makes it useful day to day is how it travels. An RFI goes out as a transmittal — the same way a drawing issue does — so it has proper recipients, a cover sheet, tracked links and somewhere for the answer to land.

Raising one: New action → Request for Information, write the question, set Response due (the form suggests 14 days), and choose the Recipients:

• Responding party — the one person who owes the answer. It defaults to the project’s superintendent if there is one in the directory, otherwise the other party to the contract. Pick anyone on the job, or Someone else with a name and email — they join the project directory once the RFI is issued.
• Copies — everyone who should see it. They can acknowledge receipt; they can’t answer.

There is no “requires client approval” on an RFI. It is answered, not approved.

Tick Issue when you save, or use Issue to Client on the action later. Either way each recipient gets an email with a link to the cover sheet, the RFI form and any documents attached to the action. The responding party’s link asks for their answer, with a place to attach a sketch or a marked-up drawing. When it comes back it lands on the action’s Response fields, the action page shows who has opened it and who has answered, and the whole trail — under the action’s own number — is in Communications. Answers that arrive by phone can be typed in with Record Response on the action, or recorded in the Communications drawer.

Re-issue after adding a document and it goes out again under the same number; the earlier links are retired so nobody holds two live copies.

For a party with no contract — a consultant, an authority — raise the RFI from Communications instead. Same delivery, no contract record; it takes a project number (RFI-0001) rather than a contract one.

Raising and issuing an action

1. Create a contract action, choosing its type and the contract it’s under. For variations, set the cost and time impact and the affected budget lines. Set the Due date if you need a response by a particular day — it’s what makes the issued action show as Overdue in the Communications register.
2. The action runs through Draft → Submitted → Client Review → Client Approved → Approved → Completed (and can be Rejected or Cancelled).
3. Issue the action — to the client or to a subcontractor. Tick Issue to client on the form or use Issue to Client on the action afterwards; either way, a client with portal access sees it there and a client without one gets a secure link by email.
4. Approve it once accepted. Approved variations flow their cost impact into the budget and their time impact into the revised PC date.

Generate the action PDF (or variation PDF) to issue formally. You can also work from action templates for the instruments you raise often.

Provisional sums and prime cost allowances

Allowances are where fixed-price jobs leak money, because the difference between what you allowed and what the client chose has to find its way into the contract sum, and usually doesn’t.

• Prime Cost (PC) — a supply item. Tapware, appliances, floor coverings.
• Provisional Sum (PS) — supply and install. Landscaping, driveways.

Both start life on the estimate (see Estimating) and flow through to the contract, the client’s selections and the final account.

The Allowance Register

Open a head contract and go to Allowance Register — one page per project showing every allowance and where it’s up to.

Four tiles across the top: Scheduled (what you allowed), Adjustments (what’s been booked), Adjusted Total, and Still Outstanding — the value of allowances nobody has chosen against yet. That last one is your exposure.

The table gives you Cost Code, Allowance, Scheduled, Selected, Adjustment, Stage and Next Action.

Stage runs Scheduled → Selected → Adjusted → Closed, and Next Action tells you whose move it is:

How the difference gets settled

When the client chooses, CortexPM drafts an Allowance Adjustment — a contract action like any other, which you review and issue.

• Over the allowance — the client pays the excess plus your margin on the excess.
• Under — they’re credited the difference in full. No margin comes off a credit.
• On the allowance — nothing to issue.

The margin rate comes from the estimate line: its Excess Margin % if you set one, otherwise its markup %.

Once the client approves the adjustment, the budget and the contract value both move, once.

Tip: the adjustment figure on the register is the one on the contract action itself, so the register and your contract paperwork always agree.

The client’s side

Your client sees one figure — the Allowance Adjustment, margin included. They never see your cost or your margin rate. Allowances show inc GST with the ex GST figure beside them, and each option shows what choosing it would cost them.

Selections are drafted from the allowances automatically and released when you’re ready — see CRM & Client Selections.

On the paperwork

The Head Contract Particulars PDF carries an Allowances section — cost code, description, amount ex GST, total, and a note on how a difference is settled. The specification carries the Allowance Schedule on the same basis, including on the fixed-price export.

Progress claims

A progress claim claims payment for work done — either your claim to the client under the head contract, or a subcontractor’s claim to you under a subcontract.

Creating a claim

1. Create a progress claim against the contract. Its structure follows the contract’s progress claim type (milestone, trade, or invoice based).
2. Build the claim items — the amounts claimed this period against milestones, trades, or (for invoice-based) the vendor invoices in the claim period plus margin.
3. CortexPM works out the amount claimed, retention held, GST and the due date (set per security-of-payment timing). Claims reference the previous claim so amounts run cumulatively.

Claim lifecycle and documents

A claim moves through Draft → Submitted → Under Review → Approved → Completed, and can be Rejected, have Changes Requested, or be Cancelled. Use status update to move it along, and generate the progress claim PDF to issue.

Claim types also include Standard, Practical Completion, Defects Liability and Final claims for the relevant stages.

Invoice-based claims

On an invoice-based head contract, each claim is built from the vendor invoices received in the claim period you set, plus an optional builder’s margin line for that period.

1. Create the claim, select the head contract, and set the claim period (start and end dates).
2. Load invoices — you’ll see the project’s vendor invoices dated within that period (invoices already paid are marked as such). Tick the ones to include. An invoice can appear on a claim only once, and it won’t be offered while it’s already on another claim for the same contract that is still in progress.
3. Add margin for the period if needed, then save.

If the client rejects a claim, the whole claim is rejected — even where the disagreement is about one line. Once a claim is Rejected or Cancelled, its invoices become available again: create a new claim, set the period and load them afresh.

Tip: if an invoice doesn’t appear when you load invoices, check its date falls inside the claim period and that it isn’t cancelled or rejected. Finish or cancel draft claims you don’t intend to use, so they aren’t holding invoices back from new ones.

What the client can do with a claim

Where a claim has been issued to a client with portal access, they get two buttons:

• Accept claim — with the note “Accepting confirms you agree with this claim. It does not process payment.”
• Request changes — which requires them to say what’s wrong.

Accepting moves the claim to Under Review, not Approved. The client agreeing isn’t the same as you certifying — only your staff approve a claim. Request changes moves it to Changes Requested and stores their note against the claim.

Either way the response appears on the claim’s own Progress & Timeline tab, the project team is emailed, and it’s logged in the activity trail. The client’s note shows on the claim page for whoever picks it up.

Watch out: the words matter if you’re explaining this to a client. They accept or request changes — they don’t approve or reject. Approval is a status only you can set.

Payment certificates

When you’re the one certifying a claim (typically against a subcontractor’s claim, or as the contract administrator), issue a payment certificate.

1. From the progress claim, create a payment certificate.
2. Set the amount certified, any adjustments (with a reason), retention and GST. CortexPM calculates the total payable.
3. The certificate runs Draft → Issued → Paid. Record the issue and due dates, and the payment date when paid.

Each certificate links one-to-one to its claim and produces a certificate document. This is how you formally certify what’s payable, separate from what was claimed.

Issuing to the other party

A contract, subcontract, variation, notice or progress claim can be issued — sent formally to the other party with a record of what went and what came back.

Issue to Client and Issue to Subcontractor sit on the contract action header. Where the client has portal access it lands in their portal; where they don’t, they get a secure link by email. No account needed either way.

What they receive is frozen. The document is pinned at the revision you issued, annexures included. Revise the contract afterwards and what they were sent still opens exactly as it was. That’s what makes “this is what you were issued” a statement you can stand behind.

What comes back. An issuance moves Sent → Viewed → Responded, with times against each, and you get a notification when a recipient opens it and when they respond. Depending on what you sent, they can acknowledge, accept, reject, or sign — signing records their typed name along with a timestamp and a fingerprint of the document. They can attach files to any response — a marked-up drawing, a signed copy — and you get them in the email and on the record.

Responses are recorded automatically. A client accepting a variation applies that acceptance to the contract action itself, so you’re not transcribing it by hand.

When it’s due. A variation issued by secure link carries the action’s Due date; an RFI its Response due; a progress claim its payment schedule date (ten business days from the claim date unless you change it). Past that date with no response, the issuance shows as Overdue in the Communications register and the Issuance Register report. Contracts and invoices don’t carry a response deadline.

See Communications for the full picture on issuing and tracking.

Retention

Retention is money held as security against the contract, released in stages.

• The retention register lists retention held across your contracts; view it on screen or as a PDF, and break it down by project.
• Retention releases record the staged release of retention (for example at practical completion and at end of the defects liability period). Create a release, set its stage and amount, update its status, and generate the release PDF.
• Retention amounts are calculated from the contract’s retention percentage and tracked per contract and per separable portion.

Certified claim and retention payments can be paid out via ABA batch file for your bank (see Accounting).

Where to next

Contract variations and claims move money in Jobs & Job Cost and Accounting. Engage your trades through Purchasing subcontract orders and give them visibility through the Subcontractor Portal; keep your client across variations and claims through the Client Portal.