Modelling the NDIS 90-day claim limit in Python: day counts, working-day deadlines and a slack score for every unpaid line

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 th

Modelling the NDIS 90-day claim limit in Python: day counts, working-day deadlines and a slack score for every unpaid line

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.

  1. 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).
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

Data model for an NDIS 90-day claim deadline: each support line stores the delivered-from date, delivered-to date, funding type and status; from these the code derives the day number, day 90, the legal deadline (30 November 2026 for supports whose day 90 falls earlier), a working deadline moved back past weekends and public holidays, and a slack score that subtracts the days the remaining steps usually take

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

Example NDIS claim report on Monday 14 December 2026 sorted by slack: a self-managed line from 30 September, invoiced, at day 76 with a working deadline of Thursday 24 December and slack of minus 7 days; a plan-managed line from 5 October, approved, at day 71 with a working deadline of Thursday 31 December and slack of minus 4; an NDIA-managed rejected line from 21 September at day 85 with a working deadline of Friday 18 December and slack of 1; a multi-day line from 9 November awaiting a timesheet with slack of 43; and a claimed line from 7 December with slack of 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. Replace the assumptions with real figures per funding type, and recalculate them each quarter.
  • Alerts. A daily job that emails whoever owns a line when its slack drops below a threshold. Keep the threshold configurable.
  • The plan manager's date. For plan-managed lines, record when the invoice was sent and when the plan manager confirmed they'd claimed it. Without those two timestamps you're guessing.

If you build NDIS bulk claim files, our glossary entry on the bulk payment request lists the file rules from the NDIA's guide, including the year-first date format and the 5,000-row limit.

Sources

  • National Disability Insurance Scheme Act 2013, section 45A (compilation in force 1 October 2026)
  • National Disability Insurance Scheme Amendment (Securing the NDIS for Future Generations) Act 2026 (No. 66, 2026): commencement table and Schedule 2 Part 5, item 89
  • Acts Interpretation Act 1901, section 36
  • NDIA: Guide to getting paid; Increasing integrity checks on older claims (5 October 2026)
  • NDIA: Bulk payment requests self-help guide for providers (December 2025), rejection codes C09, C10 and C27, as listed in Rostery's claim rejection codes tool
  • NSW public holidays from Rostery's NDIS public holidays tool (dates checked 4 October 2026)

Read 14 to 16 November 2026. The step times in the code are illustrative assumptions. Written by the Rostery team in Sydney.

Share