DEV Community

Cover image for Which date does each NDIS change key on? Modelling the 2026-27 reforms as effective-dated rules in Python and SQLite
Rostery Team
Rostery Team

Posted on

Which date does each NDIS change key on? Modelling the 2026-27 reforms as effective-dated rules in Python and SQLite

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.

One claim line, five kinds of date: keep claim records 7 years from 27 August 2026, compared with the day the claim is made; budget reset of 50% and 10% from 1 October 2026 to 30 September 2027, compared with the day a plan is created or reassessed, with renewals from 1 February 2027; inducements ban from 20 November 2026, compared with the day a gift or offer is made; 90-day claim limit from 1 December 2026, compared with the day the claim is made on our reading; four new price limits from 1 December 2026, compared with the day the support is delivered; plan renewal with no carry-over from 1 February 2027, compared with the old plan's end date

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)"),
]
Enter fullscreen mode Exit fullscreen mode

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.

When the Act and the timeline disagree: the inducements ban, Schedule 2 Part 8, starts 20 November 2026 under the Act's commencement table and 27 November 2026 in the Department timeline, so 20 to 26 November is flagged; the debt recovery rules, Schedule 3 Part 5, start 20 February 2027 under the Act and 27 February 2027 in the timeline, so 20 to 26 February is flagged

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)
Enter fullscreen mode Exit fullscreen mode

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]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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;
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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)