Originally based on our guide to the NDIS 90-day claim rule on rostery.com.au. This version is rewritten for developers, finance analysts and anyone who builds the reports behind NDIS claiming. General information only, not legal or financial advice. The day count and some edge cases below are our reading of the Act; the NDIA hasn't published guidance on them.
Australia's National Disability Insurance Scheme (NDIS) pays providers for supports delivered to participants under their plans. Until 30 November 2026, a claim for a support can be made up to 2 years after the support. From 1 December 2026 that limit drops to 90 days. The change is one amendment to section 45A(5) of the NDIS Act, made by the Securing the NDIS for Future Generations Act 2026, and it has no transitional rule for older supports.
For a provider's systems, that turns a rarely checked limit into a deadline on every line. Every completed support now has its own clock, and the clocks run in parallel. If your job is the reporting layer, the question you'll be asked is simple: which unpaid lines are going to run out of time, and how soon?
There's already a good spreadsheet answer to that question. Our Medium piece on the NDIS claim ageing report buckets lines by age and runs a weekly meeting around them. This post takes a different route. It models the rule in code, so you can test it, put it behind an API or a scheduled job, and rank lines by how much room they really have rather than by age alone.
The code uses the Python standard library only. There's a SQL version of the core query near the end.
What the rule says, as requirements
Before writing any code, it helps to turn the law into requirements a test can check.
- The window. A claim must be made "before the end of the following period starting on the day the support is provided": 90 days from 1 December 2026 (section 45A(5) as amended).
- Day 1. Section 36 of the Acts Interpretation Act 1901 says a period that begins on a day includes that day. So the support day is day 1 and day 90 is 89 days later. A support on Tuesday 1 December 2026 has day 90 on Sunday 28 February 2027.
- The switchover. The amendment applies to claims made on or after 1 December 2026, with no carve-out for older supports. Anything delivered on or before 2 September 2026 is already past day 90 on 1 December, so it has to be claimed by Monday 30 November while the 2 year limit still applies.
- Who claims. Section 45A(2): the person managing the funding, or the provider where the NDIA manages it. For plan-managed supports the plan manager claims; for self-managed supports the participant does. The 90 days apply to all of them.
- The exception. Section 45A(6) still lets the NDIA treat a late claim as made in time if exceptional circumstances justify it and the claim was made within a reasonable period. The NDIA hasn't said what it will accept, so the model treats a missed deadline as a miss.
- Weekends. Section 36(2) of the Acts Interpretation Act lets something due on a weekend or holiday be done on the next working day, but the NDIA hasn't said how its claiming system counts. Our original guide recommends treating the last working day before day 90 as the deadline, so the model keeps two dates: the legal one and a working one.
Two more details shape the data model. First, a bulk claim file has a start and an end date for each line (SupportsDeliveredFrom and SupportsDeliveredTo). The Act counts from "the day the support is provided" and doesn't say which day of a multi-day support counts. The NDIA's Guide to getting paid asks for claims within 90 days of the support "being delivered in full". Until the NDIA settles it, the cautious choice is to count from the first day. Second, a rejected payment request can't be edited. You lodge a new one, and on our reading the new request is a new claim that must itself fall inside the 90 days of the original support. Rejection doesn't reset the clock.
The data model
One row per support line is enough. The fields that matter for the deadline are the support dates, the funding type (because it decides who claims) and a status that says where the line is stuck.
Keep status as a short, fixed list. Free-text statuses make a report impossible to filter. The list used here is: timesheet pending, approved, invoiced, claimed, rejected and paid. Paid lines drop off the report.
The module
Here's the whole module. The sections after it explain the choices.
"""Claim-window arithmetic for the NDIS 90-day limit (NDIS Act s45A(5) as amended from 1 December 2026). General information only. Counting follows our reading of the Acts Interpretation Act 1901 s36: the day the support is provided is day 1. """ from dataclasses import dataclass from datetime import date, timedelta from enum import Enum NEW_LIMIT_STARTS = date(2026, 12, 1) # Schedule 2 Part 5 commencement LAST_OLD_LIMIT_DAY = date(2026, 11, 30) WINDOW_DAYS = 90 class Funding(Enum): NDIA = "ndia" # provider claims in the myplace provider portal PLAN = "plan" # plan manager claims after receiving your invoice SELF = "self" # participant or nominee claims after paying you class Status(Enum): TIMESHEET_PENDING = "timesheet_pending" APPROVED = "approved" INVOICED = "invoiced" CLAIMED = "claimed" REJECTED = "rejected" PAID = "paid" @dataclass(frozen=True) class SupportLine: line_id: str delivered_from: date # SupportsDeliveredFrom in the bulk claim file delivered_to: date # SupportsDeliveredTo funding: Funding status: Status def day_number(support_day: date, today: date) -> int: """Day 1 is the support day itself.""" return (today - support_day).days + 1 def day_90(support_day: date) -> date: return support_day + timedelta(days=WINDOW_DAYS - 1) def last_working_day(d: date, holidays: frozenset) -> date: """Move back to the nearest weekday that isn't a listed public holiday.""" while d.weekday() >= 5 or d in holidays: d -= timedelta(days=1) return d def legal_deadline(line: SupportLine) -> date: """Last day a claim can be made for this line. Supports whose day 90 falls before 1 December 2026 must be claimed by 30 November 2026, while the 2 year limit still applies. (We ignore lines already older than 2 years.) Multi-day supports count from the first day, until the NDIA says otherwise. """ d90 = day_90(line.delivered_from) return LAST_OLD_LIMIT_DAY if d90 < NEW_LIMIT_STARTS else d90 def working_deadline(line: SupportLine, holidays: frozenset) -> date: return last_working_day(legal_deadline(line), holidays) # Our assumptions about how many days each remaining step takes. Tune them to your office. DAYS_STILL_NEEDED = { Status.TIMESHEET_PENDING: 10, Status.APPROVED: 7, Status.INVOICED: 3, Status.REJECTED: 3, Status.CLAIMED: 0, Status.PAID: 0, } HANDOFF_DAYS = {Funding.NDIA: 0, Funding.PLAN: 14, Funding.SELF: 14} def slack(line: SupportLine, today: date, holidays: frozenset) -> int: """Days left to the working deadline, minus the days the remaining steps usually take.""" left = (working_deadline(line, holidays) - today).days needed = DAYS_STILL_NEEDED[line.status] if line.status not in (Status.CLAIMED, Status.PAID): needed += HANDOFF_DAYS[line.funding] return left - needed def pre_upload_problems(line: SupportLine, today: date) -> list: """Checks you can run before a file goes anywhere near the portal.""" problems = [] if line.delivered_from is None or line.delivered_to is None: problems.append("C10: support start or end date missing") return problems if line.delivered_from > today or line.delivered_to > today: problems.append("C27: support date in the future") if line.delivered_to < line.delivered_from: problems.append("end date before start date") if line.delivered_to != line.delivered_from: problems.append("multi-day line: deadline counted from the first day") return problems Day number and day 90
day_number and day_90 are one-liners, and that's the point. The off-by-one sits in exactly one place, with a docstring that says why. A common slip in deadline reports is support_date + 90 in one query and + 89 in another.
The legal deadline and the switchover
legal_deadline handles the transition. If day 90 for a line falls before 1 December 2026, the line is still claimable under the 2 year limit, but only until 30 November. From 1 December it would be out of time. So the effective deadline is 30 November. For everything else it's day 90.
The function deliberately ignores supports that are already more than 2 years old. In late 2026 those are rare, and handling them properly means modelling the old 2 year count too. If your data has them, filter them out before this step and look at them by hand.
The working deadline
last_working_day walks backwards from the legal deadline past weekends and any dates in a holiday set. The holiday set is an input, not a constant, because NDIS providers work in every state and territory and public holidays differ. You might also add your own office closure dates, since the deadline that matters in practice is the last day someone is at a desk to lodge the claim.
For testing we used New South Wales statewide public holidays from Rostery's free NDIS public holidays by state tool. In 2026 that includes Christmas Day (Friday 25 December), Boxing Day (Saturday 26 December) and an additional day for Boxing Day on Monday 28 December. In 2027 it includes New Year's Day, Australia Day on 26 January and the Easter days from 26 to 29 March. Check the dates for your own state before relying on them.
Slack instead of age
An ageing report sorts lines by how old they are. That works, but it treats a day-70 line that's already been claimed the same as a day-70 line whose timesheet nobody has submitted. slack tries to capture the difference.
It takes the days left until the working deadline and subtracts the days the remaining steps usually take. A line still waiting on a timesheet needs approval, invoicing and a claim run. A plan-managed line needs extra time for the plan manager to receive, check and claim the invoice. A self-managed line needs the participant to pay and claim.
The numbers in DAYS_STILL_NEEDED and HANDOFF_DAYS are our assumptions, chosen to make the example readable. They are not NDIA figures. The useful version of this model uses your own: look at last quarter's data and measure how long each step actually took, then plug in something like the 80th percentile.
A negative slack means the line will miss its deadline unless someone does something out of the ordinary.
Checks before upload
pre_upload_problems is a small set of checks you can run before a file goes to the portal. Two of them mirror NDIA rejection codes. C27 is "Claims can not be made for a future date". C10 is a missing support start or end date; Rostery's page for it adds a tip about Excel reformatting dates during upload. The multi-day flag isn't an error. It's there so the report can say "deadline counted from the first day" next to those lines.
Don't confuse the new rule with an older one. NDIA rejection code C09 says "A payment request can only be submitted until 90 days from the service booking end date". That's about service bookings, which apply to plans in the NDIA's older system, and it already exists. The section 45A limit runs from the support date and applies to every claim from 1 December. A line can be inside one and outside the other, so keep them as separate checks.
Tests
Deadline code is easy to get subtly wrong and easy to test. These tests pin the rule to dates you can count on a calendar.
from datetime import date from claim_window import * NSW = frozenset({date(2026,12,25), date(2026,12,26), date(2026,12,28), date(2027,1,1), date(2027,1,26), date(2027,3,26), date(2027,3,27), date(2027,3,28), date(2027,3,29)}) def line(d, funding=Funding.NDIA, status=Status.APPROVED, to=None): return SupportLine("x", d, to or d, funding, status) def test_day_one_is_the_support_day(): assert day_number(date(2026,12,1), date(2026,12,1)) == 1 assert day_90(date(2026,12,1)) == date(2027,2,28) def test_transition_edge(): assert day_90(date(2026,9,2)) == date(2026,11,30) assert legal_deadline(line(date(2026,9,2))) == date(2026,11,30) assert legal_deadline(line(date(2026,9,3))) == date(2026,12,1) assert legal_deadline(line(date(2026,8,1))) == date(2026,11,30) def test_known_dates(): assert day_90(date(2026,10,15)) == date(2027,1,12) assert day_90(date(2026,12,25)) == date(2027,3,24) assert day_90(date(2027,1,1)) == date(2027,3,31) assert day_90(date(2027,6,30)) == date(2027,9,27) def test_weekend_and_holidays(): assert working_deadline(line(date(2026,12,1)), NSW) == date(2027,2,26) assert working_deadline(line(date(2026,9,28)), NSW) == date(2026,12,24) assert working_deadline(line(date(2026,9,30)), NSW) == date(2026,12,24) def test_pre_upload(): assert "C27: support date in the future" in pre_upload_problems(line(date(2026,12,2)), date(2026,12,1)) The September cases are worth a second look. A support on Monday 28 September 2026 reaches day 90 on Saturday 26 December, which is also a public holiday. Walking back past Christmas Day lands on Thursday 24 December. A support on Wednesday 30 September reaches day 90 on Monday 28 December, the additional Boxing Day holiday in New South Wales, and lands on the same Thursday. Two supports two days apart share one working deadline. That's exactly the kind of thing a spreadsheet formula without a holiday list gets wrong.
A worked report
Here are five unpaid lines on Monday 14 December 2026. The lines are made up; the dates were calculated by the module above.
from datetime import date from claim_window import * from test_claim_window import NSW today = date(2026, 12, 14) lines = [ SupportLine("L1", date(2026,9,21), date(2026,9,21), Funding.NDIA, Status.REJECTED), SupportLine("L2", date(2026,10,5), date(2026,10,5), Funding.PLAN, Status.APPROVED), SupportLine("L3", date(2026,9,30), date(2026,9,30), Funding.SELF, Status.INVOICED), SupportLine("L4", date(2026,11,9), date(2026,11,15), Funding.NDIA, Status.TIMESHEET_PENDING), SupportLine("L5", date(2026,12,7), date(2026,12,7), Funding.NDIA, Status.CLAIMED), ] rows = sorted(lines, key=lambda l: slack(l, today, NSW)) print(f"{'line':5}{'from':12}{'day':>4} {'legal':12}{'working':12}{'slack':>6} notes") for l in rows: print(f"{l.line_id:5}{l.delivered_from.isoformat():12}{day_number(l.delivered_from, today):>4} " f"{legal_deadline(l).isoformat():12}{working_deadline(l, NSW).isoformat():12}{slack(l, today, NSW):>6} " f"{'; '.join(pre_upload_problems(l, today))}") Output, sorted by slack:
line from day legal working slack notes L3 2026-09-30 76 2026-12-28 2026-12-24 -7 L2 2026-10-05 71 2027-01-02 2026-12-31 -4 L1 2026-09-21 85 2026-12-19 2026-12-18 1 L4 2026-11-09 36 2027-02-06 2027-02-05 43 multi-day line: deadline counted from the first day L5 2026-12-07 8 2027-03-06 2027-03-05 81 Sorting by age would put L1 first, at day 85. Sorting by slack puts two younger lines above it. L3 is self-managed and already invoiced, but the participant still needs to pay and claim, and its legal deadline (Monday 28 December) is a public holiday in New South Wales, with Christmas just before it. L2 is plan-managed, and its day 90 is Saturday 2 January, with New Year's Day the Friday before. Both need a phone call this week. L1 needs its fix and a new payment request in the next few days, but nothing else depends on another person.
That ordering is the whole case for slack. Age tells you how long a line has been sitting. Slack tells you which line someone should pick up first.
The same core in SQL
If your claim data lives in a database, the day number and the legal deadline are easy to compute in a view. This is SQLite syntax; the Postgres version swaps julianday and date(..., '+89 days') for date arithmetic and an interval.
create table support_line ( line_id text primary key, delivered_from text not null, -- YYYY-MM-DD funding text not null, -- ndia | plan | self status text not null ); select line_id, cast(julianday(:today) - julianday(delivered_from) as integer) + 1 as day_number, case when date(delivered_from, '+89 days') < '2026-12-01' then '2026-11-30' else date(delivered_from, '+89 days') end as legal_deadline from support_line where status <> 'paid' order by legal_deadline; On 14 December 2026, against the same five lines, it returns:
line_id day_number legal_deadline L1 85 2026-12-19 L3 76 2026-12-28 L2 71 2027-01-02 L4 36 2027-02-06 L5 8 2027-03-06 The working deadline is harder in SQL, because you need to walk back past weekends and a holiday table. A recursive CTE can do it, but it's clearer to compute it in application code, or to keep a calendar table with a precomputed "last working day on or before" column for each date and join to it.
What we'd add next
- A per-line owner. Every line in the bottom of the report needs a name next to it.
- Measured step times.<...




