Health insurance cashless TAT: measure the clocks IRDAI sets

Three clocks, three different owners

Before writing any code, list the limits your report is measured against and who is accountable for each. IRDAI's health department FAQ gives these:

The FAQ states the limits. It does not settle every edge case about when a clock starts or pauses. Read the current IRDAI health master circular with your compliance team and write the agreed start and stop events into the report's footnote. The rest of this article covers the two cashless clocks; reimbursement TAT works in days and has its own document-chasing problem.

The event log a TPA actually has

Cashless claims live in a workflow system as timestamped events, not as a tidy table of durations. A minimal extract:

Queries matter. When the medical desk asks the hospital for an investigation report, the claim waits on the hospital, not on the insurer. Whether that waiting time counts toward the one-hour limit is exactly the question your compliance team must answer. Until they do, report both numbers.

Build durations from events in pandas

The log below is synthetic: 300 claims across three hospitals, with one in four pre-auth requests drawing a query. Hospital B was generated as slower.

import random
import pandas as pd

# Synthetic cashless-claim event log for one TPA desk (not real claims)
rng = random.Random(11)
hospitals = {"Hospital A": 1.0, "Hospital B": 1.6, "Hospital C": 0.8}  # speed factor
rows = []
start = pd.Timestamp("2026-09-01 08:00")
for cid in range(1, 301):
    hosp = rng.choice(list(hospitals))
    f = hospitals[hosp]
    t0 = start + pd.Timedelta(minutes=rng.randint(0, 20 * 24 * 60))
    rows.append((cid, hosp, "preauth_request", t0))
    t = t0
    if rng.random() < 0.25:                       # desk asks the hospital for a document
        t = t + pd.Timedelta(minutes=rng.randint(10, 40) * f)
        rows.append((cid, hosp, "query_raised", t))
        t = t + pd.Timedelta(minutes=rng.randint(20, 240))
        rows.append((cid, hosp, "query_answered", t))
    t = t + pd.Timedelta(minutes=rng.randint(15, 55) * f)
    rows.append((cid, hosp, "preauth_decision", t))
    d = t + pd.Timedelta(days=rng.randint(1, 5))
    rows.append((cid, hosp, "discharge_request", d))
    rows.append((cid, hosp, "final_auth", d + pd.Timedelta(minutes=rng.randint(40, 170) * f)))
events = pd.DataFrame(rows, columns=["claim_id", "hospital", "event", "ts"])
print(events.head(4))

Pivot to one row per claim, then compute the gross pre-auth time, the time spent waiting on a query, and the discharge time:

# One row per claim, one column per event (first occurrence of each)
wide = (events.sort_values("ts")
              .groupby(["claim_id", "hospital", "event"])["ts"].first()
              .unstack("event").reset_index())

wide["preauth_min"] = (wide["preauth_decision"] - wide["preauth_request"]).dt.total_seconds() / 60
wide["query_min"] = ((wide["query_answered"] - wide["query_raised"])
                     .dt.total_seconds().div(60).fillna(0))
wide["final_min"] = (wide["final_auth"] - wide["discharge_request"]).dt.total_seconds() / 60

summary = wide.groupby("hospital").agg(
    claims=("claim_id", "count"),
    preauth_p50=("preauth_min", "median"),
    preauth_p90=("preauth_min", lambda s: s.quantile(0.9)),
    preauth_over_60=("preauth_min", lambda s: (s > 60).mean() * 100),
    preauth_over_60_net=("preauth_min", lambda s: ((s - wide.loc[s.index, "query_min"]) > 60).mean() * 100),
    final_p90=("final_min", lambda s: s.quantile(0.9)),
    final_over_180=("final_min", lambda s: (s > 180).mean() * 100),
).round(1)
print(summary.to_string())

What the gross and net columns are telling you

Look at Hospital C. Measured gross, 29.8% of its pre-auths breach one hour. Take out the time the claim spent waiting on the hospital's reply to a query, and only 4.3% do. Almost all of Hospital C's apparent breaches are query waits, so the conversation with that hospital is about sending complete documents with the first request, not about the medical desk's speed.

Hospital B is different. Its gross and net breach rates are almost the same (55.8% and 54.0%), and its discharge P90 is 249.3 minutes against a 180-minute limit, with 41.6% of discharges over three hours. That delay is on the desk's side of the line, and it is the finding to escalate.

The medians hide all of this. Hospital A and Hospital C both have a median pre-auth well under an hour. Their P90s of 184.8 and 213.4 minutes show what the slowest tenth of patients experienced. A family waiting at the discharge counter experiences the tail, not the median.

Checks before the numbers leave your desk

• One claim, several pre-auths. Enhancement requests during a stay are fresh pre-auth events. Taking only the first occurrence, as the code does, measures the initial request; measure enhancements separately rather than letting first() hide them.
• Time zones and server clocks. If the hospital portal stamps IST and the workflow engine stamps UTC, every duration is off by 5 hours 30 minutes. A negative duration anywhere is the tell.
• Missing decision events. A claim with a request and no decision is open, not fast. Count open claims older than the limit as breaches in progress; dropping them flatters the report.
• Queries raised to stop the clock. If query rates jump near the one-hour mark, the net metric is being gamed. Plot the minute at which queries are raised; a spike at 50–59 minutes is a finding in itself.
• Night and holiday requests. Report by hour of day. Desks staffed thinly overnight often explain a hospital's tail better than the hospital does.

The scorecard for the provider-network head

The provider-network head manages hospitals, so give them one row per hospital with four numbers: claim count, pre-auth breach rate (gross and net side by side), discharge breach rate and discharge P90. Sort by discharge breaches, because that is the delay patients and relatives complain about. Beside each hospital, write one line on where the time goes: "query waits", "desk delay at discharge" or "within limits". State the definition of each clock and the date range in the page header.

Working through event logs like this, pivoting timestamps into durations and choosing percentiles over averages, is standard fare for anyone taking NeuraPath's DA track. Motor claims raise a related question about what counts in the denominator, covered in motor insurance loss and settlement ratios.