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 and how to choose between them, 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.
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. It’s worth knowing roughly what each one is for before getting lost in clause numbers.
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. It shines where the client wants strong control over design and quality.
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. The detailed procedures for payment, valuation and variations give you structure and good protection, as long as you keep up your side of the paperwork.
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
Contractors like the chance to coordinate design and build more tightly. The price for that is inheriting more design risk, and scope creep can get expensive quickly.
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 small to medium projects with some specialist work but not a huge number of bespoke clauses.
It gives you more structure than Minor Works without the full administrative weight of Standard Building. Think of it as “JCT, medium spice”.
Minor Works Building Contract
Minor Works is the go-to for smaller, simpler projects: refurbs, modest new builds and fit-outs with simple design and a limited number of trades. It’s shorter, simpler and quicker to get agreed.
That doesn’t make it risk-free. The commercial issues are very real: a single missed variation or messy final account can wipe out the margin on a small job.
There are other forms too, such as management contracts, major project forms and homeowner contracts, but for most construction businesses those four are the daily bread.
JCT contract types side by side
| JCT contract form | Typical project size / complexity | Design responsibility | Typical use case | Cost tracking & risk implications | 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 | Strong procedures for valuation and variations; good protection if you follow the processes, but lots to track | 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 | More design and coordination risk on contractor; variations can be more complex and higher-value | 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 | Reasonable structure for valuations and change without full heavy machinery; easier to administer than Standard | 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 | Less contractual structure, so you rely more on good habits for variations and records | Low – shorter contract, simpler procedures |
This table doesn’t replace reading the contracts, but it’s useful when you’re scoping or pricing and trying to work out what you’re signing up for commercially.
How to choose between the JCT contract types
When you strip away the legalese, choosing between JCT forms comes down to a few questions:
- How big and complex is the project?
- Who should carry design responsibility?
- How much procedure do you want in payment and change control?
- How sophisticated are the parties (and their admin capacity)?
You don’t need an actual flow chart to use that logic, but you can think about it as a rough path.
If the project is small and straightforward, with simple design and a few trades, Minor Works is usually the natural starting point. Pushing a small job into a Standard Building Contract can be like using a cruise ship to cross a canal. On the other hand, forcing something genuinely complex into Minor Works just because “it’s shorter” tends to lead to gaps that get filled with arguments.
If the project is medium or large and the employer wants to retain control of design with a consultant team, then you’re normally choosing between Intermediate and Standard Building. Intermediate works where the complexity is modest and the parties want structure but not full-blown mega-contract territory. Standard Building makes more sense where you have detailed documents, multiple packages and a higher risk of disputes if you don’t follow a clear playbook.
If the employer wants one party to take responsibility for both design and construction, or the contractor is best placed to coordinate complex design, then Design and Build comes into play. It suits projects where buildability, sequencing and contractor-led design input are key. It also suits clients who don’t want to manage lots of interfaces but are comfortable paying for that convenience via the contract risk profile.
Other considerations come into it too: funder requirements, sector norms, how familiar the project team is with each form. Those four questions will already get you to a sensible short list.
How your JCT choice affects tendering and pricing
The JCT form isn’t just something the legal team cares about. It directly shapes how you should price and structure your tender.
Under a Standard Building Contract, you’re often pricing against detailed drawings and bills of quantities. That encourages tight rates and makes remeasurement or valuation more structured, but it also means gaps in the documentation can come back to haunt either party. You want to be very clear on what’s included, what’s provisional, and how you’ll handle design development. A contract like this pairs naturally with a more granular internal cost structure and clear variation logs.
On a Design and Build job, the risk shifts. You might be tendering against Employer’s Requirements and offering Contractor’s Proposals. Design development and buildability tweaks are where you can win or lose margin. The contract type tells you that more of the “unknowns” sit with you: coordination, clashes, certain types of change. That should show up in your allowances, risk contingencies and the way you qualify your tender. It should also show up in how you plan to track design-related variations internally, because the contract gives you less sympathy if you simply “didn’t realise” something was your risk.
With Intermediate and Minor Works, pricing can sometimes be a bit looser. There may be fewer documents, more “standard” assumptions and less formal structure. That can feel refreshing, but it means your own documents and records carry more weight. If you’re using a simpler JCT form, think of your internal templates and checklists as the missing structure.
Whatever the form, the payment provisions matter. The way due dates, final dates and notices are set up in JCT influences how you plan your cashflow and how aggressive you can be on payment terms. More on that below.
How JCT types change your valuations, variations and admin burden
Once the project starts, the differences between JCT forms show up in the rhythm of valuations and variations.
On a Standard Building job, you might be running monthly valuations based on measured work and agreed variations against a bill of quantities. That means lots of line items, lots of measurement, and plenty of opportunities for small discrepancies to become big arguments. The upside is that the contract gives you a clear structure for handling them, as long as you keep up your side of the paperwork.
On a Design and Build project, valuations can be more milestone- or activity-based, with larger chunks of value tied to stages of work and design deliverables. Variations may be more complex, because a single design change can ripple into multiple packages. The contract doesn’t magically organise that complexity for you; your internal processes and tools do.
In Intermediate and Minor Works, things are simpler on paper. Fewer clauses, fewer procedures, fewer formal hoops to jump through. The risk is that “simpler” quietly turns into “looser”, and that important changes never make it into a proper log or agreement. That’s where checklists, variation logs and standardised payment applications really matter, because the contract itself is not going to remind you.
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.
Does the contract type change the tooling?
On paper, JCT doesn’t care whether you manage it with a ring binder, a spreadsheet or a full project cost system. In reality, your choice of contract type does affect the kind of tools that make sense.
On a complex Standard Building or Design and Build project, you’ll typically have:
- A larger contract sum with more moving parts
- A higher volume of variations, both small and large
- More stakeholders involved in valuations and decisions
That’s the sort of environment where a dedicated contract and cost management system really pays off. You want a place where the main contract sum, each variation, every application and every certificate live together in a way the whole team can see.
On more modest Intermediate and Minor Works projects, you might be tempted to stick to Excel because “it’s only a small job”. The risk is that you end up running as many small contracts in spreadsheets as you would run big ones in software, just with less structure. Even there, a lightweight setup that pulls together contract sums, variations and payment applications can save a lot of time and reduce arguments.
Most of these tools don’t care which specific JCT form you use. You configure the contract once (sum, retention, key dates, maybe a tag to say “this is D&B” or “this is Minor Works”) and then run through a standard workflow. You still need to understand the contract. The software stops you reinventing the same processes by hand on every project.
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
Those changes can also make a difference when you’re comparing forms. Tweaks to payment terms, notice requirements or risk allocation can change which form feels tolerable on a given job.
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, how to choose between them, 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:
- Getting your head straight on payment dates, notices and pitfalls:
JCT Payment Terms and Timeline - Seeing how JCT stacks up against NEC from a commercial perspective:
JCT vs NEC: Cost Control - Making sure your playbook matches the latest edition:
JCT 2024: Key Changes for Contractors, QSs and 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.