JCT Payment Terms and Timeline: A Simple Guide (with Examples)

If JCT contracts are the rulebook, the payment terms are the bit everyone quietly worries about.

Who gets paid when? What happens if an application is late? When does a pay less notice actually have to land? It’s all in the contract, but not usually in a format that helps you run a live project.

This guide is a plain-language walkthrough of JCT payment terms and the typical payment timeline, with concrete examples and the “gotchas” that regularly cost contractors money. We’ll also look at how to stop relying on memory and messy spreadsheets, and instead let your systems enforce the timeline for you.

If you’d like the wider context first, the big-picture overview is in JCT Contracts Explained: Types, Payment Terms, and How to Manage Them in Practice.

The basic JCT payment cycle

Different JCT forms and editions (JCT 2016, JCT 2024 and so on) have slightly different wording, but the backbone of the interim payment process is usually the same:

1. The contractor submits an interim application for payment.
2. There is a “due date” for payment.
3. A payment notice is issued, stating the “notified sum”.
4. If the payer wants to pay less than that sum, they must issue a pay less notice.
5. There is a “final date for payment”, by which the notified sum (subject to any valid pay less notice) must be paid.

The details matter: who can issue which notice, how the dates are calculated, and what happens if someone misses a step. But conceptually, you can picture it as a straight line:

Application → Due date → Payment notice → Pay less notice (if any) → Final date for payment.

That simple line is what we’re going to put real dates and numbers on.

If you’re not sure which JCT form you’re using, or you’re choosing one for a new project, it’s worth skimming JCT Contract Types Explained: How to Choose the Right Form for Your Project first, because the exact provisions can differ slightly between forms.

The overview from JCT itself can be a bit overwhelming, to say the least – so let’s dive into practical examples to better understand it.

A worked example: one interim payment under JCT

Let’s make this less abstract and run through a single interim payment under a JCT 2016-style contract. The principles are very similar for other recent editions.

Imagine:

• The interim valuation period runs monthly.
• The due date is the date the contractor’s interim application is received, or a specific valuation date each month (depending on the form/amendments).
• The payment notice must be issued within 5 days of the due date.
• The final date for payment is 14 days after the due date.
• Any pay less notice must be issued a set number of days before the final date for payment.

You’ll need to check your specific contract for the exact numbers, but we’ll pick some realistic ones to show the mechanics.

Say the contractor submits Application No. 5 on 1 March.

If the contract says the due date is the date of receipt, then:

• 1 March: Due date for Payment 5.
• 6 March: Last day to issue the payment notice (5 days after due date).
• 15 March: Final date for payment (14 days after due date).
• Pay less notice deadline: typically a certain number of days before 15 March (for example, not later than 7 days before the final date for payment).

Now give it a value. The contractor’s application claims:

• Gross valuation to date: £500,000
• Less previous payments: £380,000
• So amount claimed this round: £120,000

The contract administrator reviews the application and decides some work has been over-valued or not yet done. They issue a payment notice on 5 March stating:

• Notified sum: £100,000

Unless a valid pay less notice is issued on time, that £100,000 becomes the sum that must be paid by 15 March, whether or not the original application was higher.

If the payer believes the proper amount is actually £80,000, they can’t just quietly pay £80,000 and hope for the best. They need to serve a compliant pay less notice by the deadline, setting out the basis of that lower figure. If they don’t, the £100,000 stands.

That’s the heart of the JCT payment machine: the application starts the cycle, the payment notice fixes the notified sum, and the pay less notice is the last chance to move that figure down before money has to leave the bank.

If you want to see how different JCT forms handle this (and how the payment mechanisms compare to other contracts like NEC), it’s worth pairing this article with JCT vs NEC: Which Contract Works Better for Cost Control and Payment Certainty?.

Where contractors lose money on JCT payment terms

In theory, the JCT payment provisions protect both sides: the contractor knows when to apply and what will be paid; the employer has a clear structure for certifying work and raising any objections. In real projects, three problems show up again and again.

1. Late or missing applications

On many jobs, the application date is “around the end of the month” or “on the 25th, give or take”. That’s fine until a key person is off, the site team is busy, or someone forgets to send the email.

If the contract is drafted so that the application triggers the due date, a late application can push the whole payment cycle back. That means:

• Cash arrives later than planned.
• Some work might not be valued in the period you expected.
• You can struggle to keep up with supply chain payments that are on a stricter timetable.

The contract won’t chase you. If you want your applications in on time, you need your own reminders and a clear internal process.

2. Payment notices that never quite match reality

On the employer/contract administrator side, the payment notice can also go wrong:

• It’s issued late.
• It’s issued on time but in a vague, unhelpful format.
• The calculations don’t obviously tie back to the application or to the actual progress on site.

That can leave you in limbo: you’re not sure what’s been certified, what’s been rejected, and what to carry forward. Final accounts become a long argument about historic valuations because there’s no consistent story over the life of the job.

In theory JCT gives strong consequences for missing or non-compliant notices. In practice, most teams would rather avoid legal brinkmanship and just get paid correctly on time.

3. Pay less notices used as a panic button

Pay less notices are there to protect the payer’s position if new information comes to light or if the payment notice itself is wrong. They’re not meant to be a monthly “discount button”.

On live projects, you sometimes see patterns like:

• Last-minute pay less notices with thin explanations.
• Notices not clearly tied to the earlier payment notice or application.
• Notices used to claw back money that should really be dealt with as variations or defects.

If your own records aren’t tidy, it’s harder to challenge a dodgy pay less notice because you can’t quickly show what was agreed, what was valued and what remains in dispute.

4. Wrong valuation basis

This is a quieter killer.

Interim payments should reflect the proper valuation basis in the contract: percentage of work properly completed, measured quantities, agreed variations, and so on. If your internal valuations are driven by “what we need to keep the cashflow comfortable” rather than by honest progress, you’re setting up future tension with the contract administrator.

On the other side, if you’re under-valuing your own work in applications because you’re busy or conservative, you’re effectively giving the employer an interest-free loan.

The more your internal records line up with the contract’s logic, the fewer surprises you get at final account.

For a broader view of how these issues sit within the overall JCT landscape, you can cross-reference with JCT Contracts Explained: Types, Payment Terms, and How to Manage Them in Practice.

A simple monthly JCT payment timeline

Let’s build out the worked example into a full monthly rhythm you can actually picture.

Imagine your contract says:

• Interim applications are to be made on the 25th of each month.
• The due date is the same 25th.
• The payment notice must be issued within 5 days of the due date.
• The final date for payment is 14 days after the due date.
• Any pay less notice must be given no later than 5 days before the final date for payment.

For the March period, your ideal timeline looks like this:

• 25 March – You submit Interim Application No. 6, with full breakdowns and supporting information.
• 30 March – Latest date for the payment notice.
• 9 April – Latest date for a valid pay less notice.
• 8 April – A sensible internal deadline for chasing any missing payment notice and clarifying figures.
• 8–9 April – You agree any adjustments with the contract administrator so you know where you stand before the final date.
• 8 April – You make sure your own accounts team are ready for the expected cash-in.
• 8–14 April – Final date for payment lands; you check that the money actually arrives.

On paper it’s calm. In reality, if you’re also running 10 other jobs, dealing with variations and keeping the supply chain happy, it’s easy to let those dates blur.

That’s why a lot of teams end up building their own “JCT payment calendar” in Excel or Outlook, often badly. A better approach is either a clean set of templates and checklists, or a system that takes the contract dates and does the remembering for you.

JCT 2016, JCT 2024 and changes to payment provisions

The broad shape of JCT payment mechanisms has been consistent for years, but the details do evolve between editions and forms. Small changes to wording, time periods or notice requirements can make a real difference when things go wrong.

You might have one project running under a JCT 2016 form and a new one going out under a JCT 2024 version of the same family. The payment clauses will feel familiar, but they won’t be identical. If you plug all JCT jobs into the same generic process, you risk either over-complying or under-complying on at least one of them.

Rather than trying to memorise every tweak, it’s more pragmatic to keep a short “what changed that matters for payment and cost control?” summary in your playbook. That’s exactly the gap JCT 2024: Key Changes for Contractors, QSs and Cost Control is meant to fill.

How to enforce JCT payment timelines using software

The JCT payment mechanism doesn’t care whether you track it on the back of a notebook or in a modern cost management platform. But your stress levels and cash flow certainly do.

A decent setup should handle three jobs for you:

1. Remind you of key dates.
2. Store application and notice history in a way that lines up with the contract.
3. Compare valuations with your budget and contract automatically.

Let’s translate that into something less abstract.

1. Reminders and visibility

Instead of “hoping someone remembers” that the next application is due on the 25th, you can enter the contract once into a system: due dates, payment periods, final dates, any special amendments.

The system then:

• Shows upcoming application dates on a dashboard.
• Nudges the right people before deadlines.
• Flags overdue applications or missing payment notices.

That’s the idea behind tools like Automate JCT Payment Applications and Notices: you push the contract logic into software once and stop relying on shared memory.

2. Clean history of applications, notices and payments

Every interim application, payment notice, pay less notice and actual payment should leave a tidy trail:

• Application amount and basis.
• Notified sum and how it was calculated.
• Any pay less deductions with a clear breakdown.
• Actual cash received and when.

Instead of spending hours at final account digging through email chains and half-remembered spreadsheets, you can see the sequence for each period in one place.

A contract-aware system like JCT Contract Management Software for Contractors and QSs is designed to do exactly that: contract sum, variations, applications, certificates and actual payments all live in a single structured record.

3. Linking valuations to budgets and variations

The payment provisions care about properly valued work and agreed changes. Your commercial reality cares about something else as well: margin.

Ideally, each interim application isn’t just “this feels about right” but:

• Tied back to your original budget.
• Updated for agreed variations.
• Aligned with subcontractor valuations and costs.

That way, when you apply for £100,000 and get certified for £95,000, you immediately see the knock-on effect on project margin and on your ability to pay the supply chain.

Where to go next

If JCT payment terms and timelines are the bit of the contract that stresses you out, you’re not alone. The good news is that once you understand the basic cycle and set up a repeatable process, it becomes just another rhythm of the project.

To keep building out your JCT playbook, the next useful stops are:

Big picture on JCT forms and concepts:
https://planyard.com/blog/jct-contracts-explained/

Choosing and understanding your contract type:
https://planyard.com/blog/jct-contract-types-explained/
https://planyard.com/blog/jct-standard-building-contract-cost-control/
https://planyard.com/blog/jct-design-and-build-variations/
https://planyard.com/blog/jct-minor-works-contract-guide/
https://planyard.com/blog/jct-intermediate-contract-guide/

Understanding how the latest editions change the rules:
https://planyard.com/blog/jct-2024-changes-cost-control/

And when you’re ready to stop running JCT payment timelines on memory, Outlook and luck:

https://planyard.com/jct-payment-application-software/
https://planyard.com/jct-contract-management-software/

The contract sets the rules. Your systems decide whether those rules work for you or against you.