If you work in UK construction for more than about five minutes, JCT shows up.
It decides who takes which risks, how you get paid, what counts as a variation, and what happens when the programme goes sideways. And yet most people are still running JCT projects with a heroic mix of Word, Excel, Outlook and vibes.
This guide is a practical, non-dusty overview of JCT contracts for contractors, QSs and project managers. We’ll look at what JCT actually is, the main contract types, how payment and variations work in real life, and how to manage all of it without getting lost in spreadsheets.
Along the way, you’ll see links to deeper JCT articles and tools, so you can dive into the bits that matter most for your projects.
What is a JCT contract, really?
The Joint Contracts Tribunal (JCT) publishes standard form building contracts used across the UK. These contracts give you a ready-made set of rules for:
- Who does what (and when)
- How design responsibilities are shared
- How changes and delays are handled
- How and when money moves
Instead of every project reinventing the wheel, the parties pick a JCT form, agree the options and amendments, and work within that framework.
If you want to see how the different forms line up against each other, we’ve put together an overview in our guide to JCT contract types.
The main JCT contract families (without the legal lecture)
There are a lot of JCT documents, but a handful of families cover most day-to-day construction work.
Standard Building Contract
This is the classic choice for medium to large traditional projects where the employer’s team leads the design and the contractor builds.
You’ll typically see:
- Detailed drawings and specs from the employer
- Bills of quantities
- Clear separation between “designer people” and “builder people”
From a cost-control point of view, it’s powerful but admin-heavy. We’ll be breaking down the key clauses for budgets, variations and risk in our dedicated article on JCT Standard Building Contracts.
Design and Build Contract
Here the contractor takes on both design and construction, often starting from the employer’s requirements and turning them into contractor’s proposals.
This changes the commercial game:
- More design risk sits with the contractor
- Variations can be more complex, because design changes and construction changes are tangled together
- The client likes having “one throat to choke”; the contractor needs very tight control of scope and change
We’ll dig properly into that in our guide to JCT Design and Build and variations.
Intermediate Building Contract
Intermediate sits between Minor Works and Standard Building. It’s for projects that are a bit too involved for Minor Works but don’t need the full complexity of a Standard Building Contract.
Think of it as “JCT, medium spice”.
We’ll cover how to administer these contracts efficiently in our JCT Intermediate Contract guide.
Minor Works Building Contract
Minor Works is the go-to for smaller, simpler projects: refurbs, modest new builds, fit-outs.
It’s shorter and lighter, but the commercial issues are very real: a single missed variation or messy final account can wipe out the margin on a small job.
We’ll walk through the details (and how not to drown a small project in paperwork) in our JCT Minor Works guide.
If you’d like a birds-eye comparison of all of these before you pick one, start with the overview in JCT Contract Types Explained.
| JCT contract form | Typical project size / complexity | Design responsibility | Typical use case | Admin load |
|---|---|---|---|---|
| Standard Building Contract | Medium to large, higher complexity | Employer-led design (consultant team), contractor builds | Traditional projects with detailed drawings, specifications and bills of quantities | High – detailed certifications, variations and payment process |
| Design and Build Contract | Medium to large, often complex or bespoke | Contractor takes on both design and construction | “Single point responsibility” projects where the client wants one main contract | High – strong focus on scope, design risk and change control |
| Intermediate Building Contract | Small to medium, some complexity | Usually employer-designed, with some specialist work | Projects too involved for Minor Works but lighter than Standard Building | Medium – more structure than Minor Works, less than Standard |
| Minor Works Building Contract | Small, straightforward projects | Simple, usually employer-designed | Refurbishments, fit-outs, small new builds with limited complexity | Low – shorter contract, simpler procedures |
The JCT concepts that actually move your margin
Every JCT form has its own flavour, but the same big levers show up again and again. If you understand these, you understand the commercial heart of the contract.
The contract sum (and how it mutates)
The contract sum is your agreed price at the start. Under JCT, it’s not carved in stone. It can go up or down for things like:
- Variations
- Provisional sums being firmed up
- Fluctuations (if allowed)
- Certain loss and expense claims
In theory, this is clean and logical. In practice:
- Site teams get instructions verbally or in passing
- QSs hear about them weeks later
- Variations are priced long after the work is done
- The “real” contract sum only exists in someone’s personal spreadsheet
The result is that you think you’re doing fine until the final account blows up.
A healthier pattern is to treat every potential change as a small data point: log it, price it, approve or reject it, and update the contract sum as you go. That’s hard in Excel, and very natural in a dedicated system. More on that later.
Programme, delays, and relevant events
JCT expects you to plan the work and keep the programme updated. It also defines “relevant events” that might entitle you to an extension of time: exceptionally adverse weather, variations, instructions, and so on.
In commercial terms:
- If you don’t record events and notify properly, you can end up late with no extension of time and exposure to liquidated damages.
- If you split time and money into separate conversations, you create disputes for your future self.
Different standard forms handle this differently. NEC, for instance, leans heavily on early warnings and compensation events. If you work across different contract families, it’s worth seeing how JCT compares – we break that down in JCT vs NEC: cost control.
The JCT payment machine
This is where most day-to-day stress lives.
Most JCT forms follow a rhythm that looks something like:
- Contractor submits an interim application
- There’s a due date for payment
- The contract administrator/employer issues a payment notice
- There’s a final date for payment
- If they want to pay less, they serve a pay less notice
The exact details depend on the form and edition, but the pattern is the same: dates, notices, and consequences for getting them wrong.
This is why people obsess over JCT payment timelines. A missed notice or a late application can move a lot of money.
We’ve pulled this apart with examples and simple timelines in our guide to JCT payment terms and payment timelines. If your main pain with JCT is “we keep almost missing deadlines”, that one is worth a read.
If you want to go a step further and get reminders, structured applications and clean histories without manually juggling dates, there’s also a dedicated page on automating JCT payment applications.
Variations and change
Variations are where a lot of projects quietly lose money.
Under JCT, changes typically come in through instructions from the architect or contract administrator, or through other mechanisms specified in the contract. Again, in theory this is neat and ordered. On a live site, not so much.
Common reality:
- Informal instructions on the phone or in the corridor
- “We’ll sort the money later”
- A variation list that starts as a back-of-the-envelope note and reluctantly becomes an Excel file months into the job
- Replay of old arguments at final account because nothing was captured properly when it happened
The contract gives you a procedure. Your systems and habits decide whether that procedure protects you or just exists in the background while everyone improvises.
Why trying to run JCT in spreadsheets hurts so much
Spreadsheets are brilliant for quick thinking and bad at being a system of record for a multi-million-pound contract.
On a typical JCT project you’ll see:
- A contract sum in one sheet, a budget in another, and live costs in something entirely different
- Variations in an ever-growing tab where nobody is quite sure if item 37 is fully agreed or only “commercially agreed, not certified”
- Payment applications prepared manually each month, copying data across and hoping no formula broke
- Notices and certificates living as PDFs scattered across email chains
- No single place to see: original contract sum, current contract sum, variations (pending and agreed), certified to date, and forecast final account
That makes it hard to:
- Prove what was agreed
- Move quickly when the programme changes
- Forecast margin with any confidence
The JCT forms are not designed to be painful. The way we often implement them is.
Managing JCT contracts in a structured way
The contract doesn’t care how you organise yourself, as long as you follow its rules. You could, in theory, run a JCT job on paper. You probably don’t want to.
A modern, JCT-aware setup should give you:
- A clear contract record with the contract sum, retention, key dates and options
- A live view of how that sum is changing with each variation
- Payment applications generated from actual progress and agreed changes, not hand-rolled each month
- An audit trail of instructions, valuations and approvals that survives staff changes and inbox purges
That’s exactly the gap JCT contract management software exists to fill.
In Planyard’s case, for example, you can:
- Set up each JCT main contract with its sum, retention and payment profile
- Log variations as they arise and track them from “potential” to “instructed” to “agreed and paid”
- Create applications and certificates from live data instead of rebuilding them in Excel every time
- Tie everything back to budgets and subcontractor packages, so main contract JCT flows and subcontracts stay aligned
You’re still using JCT. You’re just not doing it by hand.
How JCT compares to NEC and friends
If you only ever work under JCT, you start to think “this is just how contracts are”. Then you meet NEC.
Where JCT leans on payment notices, relevant events and more traditional roles, NEC pushes early warnings, compensation events and a very programme-centric view of risk.
For cost control, the differences matter:
- How quickly changes are priced and agreed
- How tightly time and money are linked
- How much discretion the project team actually has in practice
We’ve put together a focused comparison in JCT vs NEC: which works better for cost control and payment certainty?. If your business moves between JCT and NEC, that article helps you adjust your internal playbook for each.
JCT 2016, JCT 2024, and the “which edition is this?” problem
To make things more interesting, not every project is on the same edition of JCT. You might have live jobs under older editions, new work under JCT 2016 forms, and upcoming tenders using JCT 2024.
The details matter. Changes between editions can tweak:
- Payment provisions
- Design responsibility wording
- Insurance options
- Digital information and collaboration clauses
Rather than memorising every clause number, it’s more practical to understand what changed and how it affects your admin, cashflow and risk. We’re unpacking that in our guide to JCT 2024 changes for contractors and QSs.
Where to go next
This article is the “big picture” of JCT: what it is, which forms dominate real projects, and why payment and variations are where most of the pain and risk live.
From here you can zoom in on whatever is currently keeping you up at night:
- Choosing between JCT forms:
JCT Contract Types Explained - Getting your head straight on payment dates, notices and pitfalls:
JCT Payment Terms and Timeline - Understanding the quirks of each main contract type:
JCT Standard Building Contract: Cost Control
JCT Design and Build: Variations
JCT Minor Works: Contract Guide
JCT Intermediate Contract Guide - Seeing how JCT stacks up against NEC from a commercial perspective:
JCT vs NEC: Cost Control - Moving away from juggling JCT in spreadsheets entirely:
JCT Contract Management Software
JCT Payment Application Software
The contracts aren’t going away any time soon. The way you manage them can absolutely evolve.
How Planyard can help
If you’re already juggling JCT payment cycles, variations and final accounts, you don’t need more theory – you need a smoother way to run the contract day to day. Planyard lets you track contract sums, variations, applications and certifications in one place, so your JCT admin supports the project instead of slowing it down.
See how it works in practice.