Originally based on our hub of NDIS changes in 2026 and every date for providers on rostery.com.au. This version is rewritten for developers and data people who maintain NDIS billing, rostering or plan management systems. General information only, not legal advice. Where the code makes a choice the law doesn't spell out, it's marked as our reading.
Australia's National Disability Insurance Scheme (NDIS) is in the middle of its biggest set of rule changes in years. Most of them come from one Act passed in August 2026, the Securing the NDIS for Future Generations Act 2026, plus a price notice from the NDIA (the agency that runs the scheme) and the Department's guidance on funding changes.
If you maintain software that rosters, bills or claims NDIS supports, you've probably been handed a list of dates. A list of dates is a good start, but it isn't a specification. The bug that will actually bite isn't getting a start date wrong. It's comparing the right start date with the wrong date on the record.
Take a support delivered on Saturday 28 November 2026 and claimed on Thursday 3 December. Is it priced at the old rate or the new one? Is it under the old 2-year claim limit or the new 90-day one? The answers are different, because the two rules look at different dates on the same line. This post models six changes as effective-dated rules, each with an explicit trigger, and tests the edges.
Five kinds of date on one claim line
A typical claim line carries more dates than people expect. For these reforms, five matter:
- Delivery date: the day the support was provided.
- Claim date: the day the claim is made to the NDIA (or by the plan manager, or by a self-managing participant).
- Conduct date: the day a gift, benefit or offer is made. It isn't on the claim line at all, but it belongs in the same rules table.
- Plan event date: the day a participant's plan is created, reassessed or renewed.
- Plan end date: the day an old framework plan ends.
Here's what each rule keys on, and where it comes from:
| Rule | Starts | Keys on | Source |
|---|---|---|---|
| Keep claim records for 7 years | 27 Aug 2026 | Claim date | Act s2 item 7; new s45B; item 88 |
| Budget reset (50% and 10%) | 1 Oct 2026 to 30 Sep 2027 | Plan event date | NDIS Act s34A; Department guide |
| Inducements ban | 20 Nov 2026 | Conduct date | Act s2 item 9B; new s73VA |
| 90-day claim limit | 1 Dec 2026 | Claim date (our reading) | Act s2 item 8; Sch 2 item 89 |
| Four price limits rise | 1 Dec 2026 | Delivery date | NDIA price notice |
| Plan renewal, no carry-over | 1 Feb 2027 | Plan end date | Act s2 item 4; new s50A |
The rules table
The model is a frozen dataclass and a list. The point isn't cleverness; it's that every rule carries its trigger and its source, so a reviewer can check one row against one document.
class Trigger(str, Enum):
DELIVERY = "delivery" # the day the support was provided
CLAIM = "claim" # the day the claim is made
CONDUCT = "conduct" # the day a gift or offer is made
PLAN_EVENT = "plan_event" # a plan is created, reassessed or renewed
PLAN_END = "plan_end" # an old framework plan reaches its end date
@dataclass(frozen=True)
class Rule:
key: str
summary: str
trigger: Trigger
starts: date
source: str
ends: date | None = None
other_dates: tuple[tuple[date, str], ...] = field(default_factory=tuple)
def in_force(self, on: date) -> bool:
return self.starts <= on and (self.ends is None or on <= self.ends)
def disputed(self, on: date) -> bool:
"""True if another published source would give a different answer on this day."""
return any(self.in_force(on) != (d <= on) for d, _ in self.other_dates)
RULES = [
Rule("records_7y", "Keep records behind a claim for 7 years from the claim day",
Trigger.CLAIM, date(2026, 8, 27), "Act No. 66, s2 item 7; Sch 2 Part 4 (s45B, item 88)"),
Rule("budget_reset", "SECP funding cut 50%, IDLS 10%, when a plan is created, reassessed or renewed",
Trigger.PLAN_EVENT, date(2026, 10, 1), "NDIS Act s34A; Department funding changes guide",
ends=date(2027, 9, 30)),
Rule("inducements", "Ban on gifts or benefits likely to win, keep or grow business (s73VA)",
Trigger.CONDUCT, date(2026, 11, 20), "Act No. 66, s2 item 9B; Sch 2 Part 8",
other_dates=((date(2026, 11, 27), "Department timeline, September 2026"),)),
Rule("claim_90d", "Claims must be made within 90 days of the support (s45A(5)(a))",
Trigger.CLAIM, date(2026, 12, 1), "Act No. 66, s2 item 8; Sch 2 Part 5 (item 89)"),
Rule("price_1dec", "Higher price limits for four support items",
Trigger.DELIVERY, date(2026, 12, 1), "NDIA notice: NDIS price increase from 1 December 2026"),
Rule("plan_renewal", "Plan renewed as a new 12-month plan at its end date; unspent funds stay behind",
Trigger.PLAN_END, date(2027, 2, 1), "Act No. 66, s2 item 4; Sch 1 Part 5 (s50A)"),
]
SECP and IDLS are the two budget groups the reset touches: social, economic and community participation, and improved daily living skills.
When two official sources disagree
You'll notice other_dates. It exists because the Act and the Department's published timeline don't always agree.
The Act's commencement table says Schedule 2, Part 8 (the inducements ban) starts "the day after the end of the period of 3 months beginning on the day this Act receives the Royal Assent", and the table's information column gives 20 November 2026. The Department's September 2026 timeline lists the ban under 27 November. The same pattern shows up for the new debt recovery process in Schedule 3, Part 5: the Act's table says 20 February 2027, and the timeline says 27 February.
The Act is what starts a law, so starts holds the Act's date. But throwing the other date away loses information a compliance lead might need, so it's stored with its source, and disputed() returns True for any day on which the two sources would give different answers. For the ban, that's 20 to 26 November. A report can show those days in amber rather than pretending the question never came up.
Debt recovery isn't in the rules list above, because it isn't triggered by anything on a claim line. It would sit in the same table in a fuller model, with the same treatment.
Claim limits: the transition turns on the claim date
From 1 December 2026, section 45A(5)(a) of the NDIS Act says "90 days" where it used to say "2 years". The period starts on the day the support is provided, and under section 36 of the Acts Interpretation Act a period that starts on a day includes that day. So day 90 is the delivery date plus 89 days.
The harder question is which supports the new limit covers. Schedule 2, Part 5 has no application or transitional provision. The explanatory memorandum says the start was delayed to 1 December "to allow sufficient time for claims older than 90 days to be made before the new timeframe takes effect". Our reading is that the limit that applies depends on the day the claim is made, which is how the function is written:
NINETY_DAY_START = BY_KEY["claim_90d"].starts
def _anniversary(d: date, years: int) -> date:
try:
return d.replace(year=d.year + years)
except ValueError: # 29 February: our reading, use 28 February
return d.replace(year=d.year + years, day=28)
def last_claim_day(delivered: date, claim_made: date) -> date:
if claim_made >= NINETY_DAY_START:
return delivered + timedelta(days=89)
return _anniversary(delivered, 2) - timedelta(days=1)
def in_time(delivered: date, claim_made: date) -> bool:
return claim_made <= last_claim_day(delivered, claim_made)
That gives a sharp edge. A support delivered on Wednesday 2 September 2026 and claimed on Monday 30 November is in time under the old limit. The same support claimed on Tuesday 1 December is on day 91 and late. A support delivered on 3 September and claimed on 1 December is on day 90 and fine.
Two things the function deliberately doesn't do. It doesn't apply section 36(2) of the Acts Interpretation Act, which lets something due on a weekend or holiday be done on the next working day; we'd rather a system warn early than rely on that. And it doesn't model section 45A(6), which lets the NDIA CEO accept a late claim in exceptional circumstances. That's a human decision, so it belongs in a workflow, not a date function. Our earlier post on modelling the NDIS 90-day claim limit in Python goes further into working-day deadlines.
Prices: keyed on the delivery date
The NDIA's notice on the 1 December price increase lists four items whose national price limits rise, for example House Cleaning and Other Household Activities (01_020_0120_1_1), from $60.10 to $64.59 an hour. It says the new prices "apply to eligible supports delivered on or after 1 December 2026" and that providers should use the price that applied on the date the support was delivered. So the trigger is the delivery date, whatever day the claim goes in.
PRICES = {
"01_019_0120_1_1": [(date.min, 59.01), (date(2026, 12, 1), 63.42)],
"01_020_0120_1_1": [(date.min, 60.10), (date(2026, 12, 1), 64.59)],
"01_004_0107_1_1": [(date.min, 61.16), (date(2026, 12, 1), 65.73)],
"01_016_0104_1_1": [(date.min, 61.16), (date(2026, 12, 1), 65.73)],
}
def price_limit(item: str, delivered: date) -> float:
rows = [p for start, p in PRICES[item] if start <= delivered]
return rows[-1]
date.min here just means "before 1 December". In a real system this table is your price book, loaded as versions rather than edited in place. That's the approach Rostery's help page on price books describes: when the NDIA publishes a new guide, you load it rather than editing the old one. Rostery's NDIS claiming software page puts the consequence plainly: the price guide is loaded as dated versions, "so a support delivered before a price change is still claimed at the price that applied then". If you want to see how often these limits move mid-year, the NDIS price limit history tool marks every mid-year change since 2019-20.
The budget reset: keyed on the plan event
The Department's guide says the funding change applies when plans are created, reassessed or renewed between 1 October 2026 and 30 September 2027, and that it begins to apply to renewals from 1 February 2027. It also says the reset doesn't apply to new framework plans. That's three conditions, and the function checks all of them:
def reset_applies(event: str, event_day: date, framework: str = "old") -> bool:
if framework != "old" or not BY_KEY["budget_reset"].in_force(event_day):
return False
if event == "renewed":
return event_day >= BY_KEY["plan_renewal"].starts
return event in ("created", "reassessed")
def reset_amount(group: str, amount: float, excluded: float = 0.0) -> float:
cut = {"SECP": 0.50, "IDLS": 0.10}[group]
return round(excluded + (amount - excluded) * (1 - cut), 2)
excluded is the part of the budget in excluded subgroups, such as supports in employment, which isn't cut. The Department publishes worked examples, which make good test fixtures because someone else did the arithmetic. Connor has $73,000 for community participation, of which $46,000 is employment support, and ends up with $59,500. Omar's $40,000 becomes $20,000 at renewal, and when a later reassessment sets $35,000, the amount available is $17,500.
One design note. Section 34A says the reduced amount is what the plan's funding component amount is "taken instead to be". The plan document itself isn't rewritten. If your system stores plan budgets, store the stated amount and the reduced amount as separate fields, with the event that triggered the reduction. Otherwise you'll eventually import a plan and not know which figure you're holding.
Plan renewal: keyed on the end date
From 1 February 2027, new section 50A renews an old framework plan as a new plan immediately after its end date. The new plan's end date is "the 12 month anniversary of the end date for the old plan", and it doesn't include one-off funding. Transitional provisions turn reassessment dates on or before 1 October 2027 into end dates; later ones get a date set by the Minister, which can be earlier.
TRANSITION_CUTOFF = date(2027, 10, 1)
def end_date_from_reassessment(reassessment: date) -> date | None:
return reassessment if reassessment <= TRANSITION_CUTOFF else None
def renewed_plan(old_end: date) -> tuple[date, date]:
return old_end + timedelta(days=1), _anniversary(old_end, 1)
Returning None for later dates is deliberate. The honest answer is "not known yet", and a function that guessed would be wrong in a way nobody would notice.
The 29 February case is our reading again: a plan ending on 29 February 2028 renews to 28 February 2029. The renewal also matters for billing: a support delivered on or before the old end date belongs to the old plan, and unspent money doesn't follow it. Our guide to unspent NDIS funds and the end of plan rollovers covers what that means operationally.
One line, every rule
With each rule keyed correctly, checking a line is just calling them in turn:
def check_line(item, delivered, claim_made, plan_end=None) -> dict:
out = {
"price": price_limit(item, delivered),
"last_claim_day": last_claim_day(delivered, claim_made),
"in_time": in_time(delivered, claim_made),
"keep_until": _anniversary(claim_made, 7) - timedelta(days=1)
if BY_KEY["records_7y"].in_force(claim_made) else None,
}
if plan_end is not None:
out["plan"] = "old plan" if delivered <= plan_end else "renewed plan"
return out
Here's the demo output for five invented cleaning lines for one participant whose plan ends on 31 January 2027:
line delivered claimed price last day in time plan keep until
L1 02 Sep 2026 01 Dec 2026 60.10 30 Nov 2026 NO old plan 30 Nov 2033
L2 28 Nov 2026 03 Dec 2026 60.10 25 Feb 2027 yes old plan 02 Dec 2033
L3 02 Dec 2026 05 Mar 2027 64.59 01 Mar 2027 NO old plan 04 Mar 2034
L4 29 Jan 2027 10 Feb 2027 64.59 28 Apr 2027 yes old plan 09 Feb 2034
L5 03 Feb 2027 10 Feb 2027 64.59 03 May 2027 yes renewed plan 09 Feb 2034
L2 is the line from the start of this post. It's priced at the old rate, because it was delivered before 1 December, and it's under the 90-day limit, because it was claimed after. L4 and L5 are claimed on the same day at the same price, yet belong to different plans. L1 and L3 are late for different reasons. The records rule still gives them a keep-until date, because section 45B counts from the day a claim is made, and that date follows the same reading as our earlier dev.to post on the 7-year rule.
The same idea in SQL
If your claim lines live in a database, the trigger can be a column, and one join finds which line-level rules apply:
SELECT l.id, r.key,
CASE r.trigger WHEN 'delivery' THEN l.delivered ELSE l.claimed END AS keyed_on
FROM claim_line l
JOIN rule r
ON r.trigger IN ('delivery','claim')
AND (CASE r.trigger WHEN 'delivery' THEN l.delivered ELSE l.claimed END)
BETWEEN r.starts AND COALESCE(r.ends, '9999-12-31')
ORDER BY l.id, r.key;
Run against three of the lines above in SQLite, it returns:
L1 | claim_90d | 2026-12-01
L1 | records_7y | 2026-12-01
L2 | claim_90d | 2026-12-03
L2 | records_7y | 2026-12-03
L3 | claim_90d | 2027-03-05
L3 | price_1dec | 2026-12-02
L3 | records_7y | 2027-03-05
L2 picks up the 90-day rule but not the price rise. That's the whole argument of this post in one row. A second table, rule_other_date, holds the Department's dates next to the Act's, so the dispute window can be queried too.
Tests at the edges
The tests are short and aimed at the boundaries, where these rules go wrong:
def test_transition_turns_on_claim_day():
assert in_time(date(2026, 9, 2), date(2026, 11, 30)) # 2-year limit still applies
assert not in_time(date(2026, 9, 2), date(2026, 12, 1)) # day 91 under the new limit
assert in_time(date(2026, 9, 3), date(2026, 12, 1)) # day 90
def test_reset_events():
assert reset_applies("reassessed", date(2026, 10, 1))
assert not reset_applies("renewed", date(2026, 12, 15)) # renewals only from 1 Feb 2027
assert reset_applies("renewed", date(2027, 2, 1))
assert not reset_applies("created", date(2027, 10, 1))
assert not reset_applies("created", date(2027, 4, 1), framework="new")
def test_department_examples():
assert reset_amount("SECP", 73000, excluded=46000) == 59500 # Connor
assert reset_amount("SECP", 40000) == 20000 # Omar at renewal
assert reset_amount("SECP", 35000) == 17500 # Omar after reassessment
All eight tests in the module pass, and every date in the demo output above came from running it.
What this model leaves out
Plenty, on purpose:
- Rules not made yet. Section 45B says the kinds of records to keep will be set by NDIS rules. Section 73VA lets rules define legitimate pricing practices, merchandise and permitted conduct. We couldn't find any of those rules when we checked on 20 November 2026, so the model has nothing to encode.
- Funding periods. Plans release funding in periods, usually 3 months, and section 34A spreads the reduction across them. A real budget check needs period-level data.
- The high support needs pathway. Participants with 24-hour supports can apply for a variation within 90 days of the reset. That's a case workflow, not a date rule.
- Provider registration and enrolment. The Department's timeline puts new enrolment and expanded registration from 1 July 2027. They key on the provider, not the line, so they belong in a different table.
The broader lesson holds for any regulated system. Store the rule, its start date, the date it compares with and its source, and test the day before and the day of. When two official sources disagree, keep both and say so.
Sources
- National Disability Insurance Scheme Amendment (Securing the NDIS for Future Generations) Act 2026 (No. 66, 2026), as made: section 2 (commencement table items 4, 7, 8, 9B and 10B); Schedule 1, Part 5 (new section 50A and transitional end dates); Schedule 2, Parts 4, 5 and 8. Read 20 November 2026.
- NDIS Act 2013, sections 34A, 45A and 45B as amended. Acts Interpretation Act 1901, section 36.
- Revised explanatory memorandum to the Bill (August 2026), Schedule 2, Part 5.
- NDIA, NDIS price increase from 1 December 2026: Gender-based undervaluation priority awards review. Read 20 November 2026.
- Department of Health, Disability and Ageing, Funding changes for NDIS supports (web page and September 2026 guide) and Securing the NDIS for future generations timeline (September 2026). Read 20 November 2026.
- Rostery, NDIS changes 2026: every date for providers.


Top comments (0)