IFRS 17 & LDTI Filing Automation

IFRS 17 and the US GAAP Long-Duration Targeted Improvements (LDTI) rewrote how insurers measure and disclose long-duration contracts, turning a once-static reserve into a moving, assumption-sensitive measurement that must be rebuilt every reporting period. This page maps the full measurement-to-disclosure pipeline for both regimes and links out to the deep-dive frameworks for each stage: Contractual Service Margin Automation, IFRS 17 Discount Rate Unlocking, LDTI Cohort & Transition Management, and Risk Adjustment & Coverage Units.

Why This Domain Exists #

For two decades, long-duration insurance liabilities were measured on assumptions locked at issue and rarely disturbed. IFRS 17, effective 1 January 2023, and the FASB’s LDTI (ASU 2018-12), effective the same year for large filers, ended that. Both standards demand a current-measurement liability that is remeasured on updated assumptions, discounted at a defensible current or locked-in curve, and disclosed through a granular movement analysis that ties opening balances to closing balances line by line. A number that used to change once a year now changes every quarter, and the audit committee expects the movement to be explained to the dollar.

• IFRS 17 measures a group of insurance contracts as fulfilment cash flows — the probability-weighted present value of future cash flows plus a risk adjustment for non-financial risk — together with a contractual service margin representing unearned profit. Its General Measurement Model, Premium Allocation Approach, and Variable Fee Approach each carry different mechanics, but all resolve to the same disclosure: a reconciliation of the liability for remaining coverage and incurred claims (IFRS 17 paragraphs 100–109).
• LDTI (ASU 2018-12) keeps the net premium reserve structure of US GAAP but forces annual assumption review, a net premium ratio capped at 100%, remeasurement of the liability for future policy benefits through current-period earnings, fair-value measurement of market risk benefits, and a simplified, constant-level amortization of deferred acquisition costs.
• Both regimes are assumption-driven and cohort-based. Contracts are grouped — by issue year and profitability under IFRS 17, by issue-year cohort under LDTI — and each group carries its own measurement history that must reconcile across periods.

The cost of ignoring the automation problem is not a fine; it is a close process that cannot land on time. A manual IFRS 17 close that recomputes fulfilment cash flows, rolls forward the margin, and assembles the disclosure in disconnected spreadsheets will miss the reporting calendar, fail audit reproducibility, and leave the movement analysis unexplained. This domain treats the standards as an executable pipeline so that the disclosure is a by-product the system guarantees, not a reconciliation the team performs by hand at quarter-end.

The engineering foundations this domain builds on live in sibling areas of this site: assumption setting and drift control belong to Assumption Validation & Rule Engine Design, the upstream data contracts and scenario machinery belong to Actuarial Model Ingestion & Testing Workflows, and the reproducibility and lineage requirements are shared with Regulatory Architecture & Compliance Mapping.

Architecture Overview #

The pipeline moves left to right: seriatim policy and assumption data are ingested and grouped into measurement cohorts, fulfilment cash flows are projected and discounted, a risk adjustment and contractual service margin are established, the margin is rolled forward and released, and the movement is assembled into a disclosure package. Every stage pins the assumption set and curve version it consumed, so a closing balance can always be traced back to the inputs that produced it.

The sections below walk each phase in turn, with a runnable Python pattern and the measurement logic behind it.

Phase 1 — Cohort Grouping & Data Contracts #

Both standards begin by partitioning the book into measurement units. Under IFRS 17 (paragraphs 14–24) contracts are grouped by portfolio, issued no more than a year apart, and split into onerous, no-significant-risk-of-becoming-onerous, and remaining groups. LDTI groups by annual issue-year cohort within a product. The grouping is not cosmetic: it determines the level at which the margin, the loss component, and the net premium ratio are tracked, and a mis-assigned policy silently distorts every downstream number. The mechanics of building stable, reproducible cohorts are covered in LDTI Cohort & Transition Management.

Because cohort identity must be stable across every future valuation, it is derived deterministically from immutable policy attributes rather than assigned by row order. Enforcing that contract at ingestion — the discipline detailed in Schema Validation with Pydantic & Great Expectations — is what keeps a June close reconcilable against the prior March close.

from datetime import date
from pydantic import BaseModel, Field

class ContractGroup(BaseModel):
    """One IFRS 17 / LDTI measurement cohort key."""
    portfolio: str
    issue_year: int = Field(ge=1900, le=2100)
    profitability_bucket: str          # "onerous" | "no_risk" | "remaining"
    cohort_id: str

def assign_cohort(policy_id: str, portfolio: str, issue_date: date,
                  expected_profit_margin: float) -> ContractGroup:
    bucket = ("onerous" if expected_profit_margin < 0
              else "no_risk" if expected_profit_margin < 0.02
              else "remaining")
    cohort_id = f"{portfolio}:{issue_date.year}:{bucket}"
    return ContractGroup(
        portfolio=portfolio,
        issue_year=issue_date.year,
        profitability_bucket=bucket,
        cohort_id=cohort_id,
    )

Phase 2 — Fulfilment Cash Flows & Discounting #

With cohorts fixed, the engine projects the probability-weighted cash flows for each group and discounts them. The present value of fulfilment cash flows for a group is

$$\text{PV}_{\text{FCF}} = \sum_{t=1}^{n} v(t)\,\mathbb{E}\!\left[\,CF_t\,\right], \qquad v(t) = \prod_{k=1}^{t} \frac{1}{1 + f_k},$$

where $f_k$ is the forward rate for period $k$ on the chosen IFRS 17 curve. The curve is not a free choice: it is either bottom-up (a risk-free term structure plus an illiquidity premium) or top-down, and the locked-in curve used to accrete the margin differs from the current curve used to remeasure the liability. That distinction, and how to unlock it as rates move, is the whole subject of IFRS 17 Discount Rate Unlocking.

import numpy as np

def pv_fulfilment_cash_flows(expected_cash_flows: np.ndarray,
                             forward_rates: np.ndarray) -> float:
    """PV of a cohort's expected cash flows on a forward-rate curve.

    expected_cash_flows: shape (n_periods,), probability-weighted per period.
    forward_rates: shape (n_periods,), period forward rates on the IFRS 17 curve.
    """
    discount_factors = np.cumprod(1.0 / (1.0 + forward_rates))
    return float(expected_cash_flows @ discount_factors)

The probability weighting behind expected_cash_flows is where mortality, lapse, and expense assumptions enter, and their governance is shared with the assumption framework rather than reinvented here.

Phase 3 — Risk Adjustment & Contractual Service Margin #

The fulfilment cash flows are only two of the three IFRS 17 building blocks. The third pair is the risk adjustment for non-financial risk — compensation the insurer requires for bearing uncertainty in the timing and amount of cash flows (IFRS 17 paragraph 37) — and the contractual service margin, the unearned profit recognised over the coverage period. At initial recognition the margin is set so that no gain arises on day one; if the group is onerous, the shortfall is booked immediately as a loss component instead. Establishing and releasing the risk adjustment and mapping it to coverage units is covered in Risk Adjustment & Coverage Units.

def initial_csm(pv_fulfilment: float, risk_adjustment: float,
                pv_premiums: float) -> tuple[float, float]:
    """Split day-one measurement into CSM and loss component.

    A negative fulfilment result at inception becomes unearned profit (CSM);
    a positive one is an onerous loss recognised immediately.
    """
    fulfilment_result = pv_fulfilment + risk_adjustment - pv_premiums
    if fulfilment_result <= 0:
        return -fulfilment_result, 0.0      # csm, loss_component
    return 0.0, fulfilment_result

Phase 4 — Roll-Forward & Release #

The signature of both standards is the periodic roll-forward. Each reporting period the contractual service margin accretes interest at the locked-in rate, absorbs the effect of new contracts and of assumption changes that relate to future service, and releases an amount to profit driven by the coverage units provided in the period. LDTI runs the analogous mechanic through its net premium ratio, remeasuring the liability for future policy benefits when experience deviates. The full roll-forward, including the order in which adjustments are applied, is detailed in Contractual Service Margin Automation and made concrete in Automating CSM Roll-Forward in Python.

def roll_forward_csm(opening_csm: float, accretion_rate: float,
                     new_business_csm: float, fcf_change_future_service: float,
                     coverage_units_current: float,
                     coverage_units_remaining: float) -> dict:
    """One period's CSM movement, released on the coverage-unit fraction."""
    after_accretion = opening_csm * (1.0 + accretion_rate)
    after_new_business = after_accretion + new_business_csm
    after_fcf = max(after_new_business + fcf_change_future_service, 0.0)
    release_fraction = coverage_units_current / (
        coverage_units_current + coverage_units_remaining)
    released = after_fcf * release_fraction
    return {
        "released_to_profit": released,
        "closing_csm": after_fcf - released,
    }

The release fraction is where the measurement meets the assumption base: coverage units depend on the expected in-force pattern, which depends on lapse and mortality assumptions governed elsewhere on this site.

Assumption Governance #

An IFRS 17 or LDTI balance is only as defensible as the assumptions beneath it, and both standards force those assumptions to move. IFRS 17 distinguishes changes in financial assumptions (which flow through insurance finance income or expense) from changes in non-financial assumptions relating to future service (which adjust the margin); LDTI requires an annual review of cash-flow assumptions with the effect flowing through the net premium ratio. Getting the split wrong misstates both the income statement and the closing liability.

Every assumption set therefore enters the pipeline versioned, dated, and approved, and any material shift is caught before it reaches measurement by Dynamic Threshold Tuning for Assumption Drift. The interest and discount assumptions in particular are governed by Interest Rate Assumption Governance, so the locked-in and current curves used in measurement are the same curves an auditor can independently reconstruct. This governance is the reason a movement analysis can attribute a change in the liability to a specific assumption revision rather than to unexplained noise.

Regulatory Audit Trail Requirements #

Because the disclosure is rebuilt every period from versioned inputs, the audit trail is not optional infrastructure — it is the only thing that makes the movement analysis auditable. Three structural requirements carry over directly from the compliance architecture used for statutory filings:

1. Reproducible measurement. Every closing balance must be regenerable from its pinned assumption set, curve version, and cohort mapping. The reproducibility discipline is shared with Ensuring Seed Reproducibility in Monte Carlo Reserves where stochastic components are involved.
2. Immutable lineage. Each period’s inputs and outputs are fingerprinted and chained, so a restated prior period is a new, referenced record rather than an in-place edit — the pattern in Hash-Chaining Audit Logs for Actuarial Filings.
3. An auditor-navigable package. The movement analysis, assumption versions, and curve snapshots are bundled so an auditor can reconstruct the close without touching the running system, extending the approach in Assembling Examiner-Ready Filing Packages.

The broader mapping between these controls and the statutory regimes is the subject of Regulatory Architecture & Compliance Mapping.

Failure Modes & Operational Risk #

IFRS 17 and LDTI pipelines fail in characteristic ways, and each has a known mitigation. Designing for these before the first live close is what keeps the reporting calendar intact.

• Cohort remapping instability. A policy that lands in a different cohort between two valuations breaks the movement analysis. Mitigation: derive cohort identity deterministically from immutable attributes and assert stability against the prior close.
• Curve confusion. Accreting the margin on the current curve instead of the locked-in curve, or vice versa, misstates insurance finance expense. Mitigation: store both curves explicitly per cohort and reference them by name, never by position.
• Onerous-group leakage. Failing to floor the margin at zero hides a loss component that should hit earnings immediately. Mitigation: enforce the floor in the roll-forward and reconcile the loss component separately.
• Assumption-change misclassification. Booking a future-service assumption change through profit instead of the margin distorts the income statement. Mitigation: classify every assumption delta at the boundary and route it deterministically.
• Close-calendar miss. The measurement is reproducible but slow, and the quarter-end window is fixed. Mitigation: vectorize the projection, checkpoint long runs, and monitor the close as an SLA — the disciplines in Sensitivity Analysis & Stress Testing and Checkpointing and Resuming Failed Actuarial Batch Runs.

Compliance Mapping Table #

The table below maps each requirement to the pipeline component that satisfies it and the implementation artifact that proves it.

Related #

• Contractual Service Margin Automation — establishing and rolling forward the unearned-profit margin.
• IFRS 17 Discount Rate Unlocking — locked-in versus current curves and the OCI option.
• LDTI Cohort & Transition Management — issue-year grouping and the transition approaches.
• Risk Adjustment & Coverage Units — non-financial risk compensation and CSM release drivers.
• Regulatory Architecture & Compliance Mapping — the shared audit-trail and reproducibility controls.

Up: Actuarial Validation & Filing Automation — the home for regulatory filing automation, assumption validation, and model ingestion workflows.

Frequently Asked Questions #

What is the difference between IFRS 17 and LDTI? #

IFRS 17 is the IASB standard that measures insurance contracts as fulfilment cash flows plus a risk adjustment and a contractual service margin, disclosed through a movement analysis. LDTI is the FASB’s US GAAP update (ASU 2018-12) that retains the net premium reserve structure but forces annual assumption review, a net premium ratio capped at 100%, and fair-value measurement of market risk benefits. Both make long-duration liabilities assumption-driven and cohort-based, which is why they share an automation pipeline.

Why does the contractual service margin need a roll-forward every period? #

The margin represents unearned profit that is recognised as coverage is provided. Each period it accretes interest at the locked-in rate, absorbs new business and future-service assumption changes, and releases an amount to profit based on coverage units. Because every one of those movements must be disclosed and reconciled, the roll-forward is rebuilt from versioned inputs each reporting date rather than carried forward as a single number.

Which discount curve does IFRS 17 require? #

IFRS 17 permits a bottom-up curve (a risk-free term structure plus an illiquidity premium) or a top-down curve derived from a reference portfolio. The locked-in curve set at initial recognition is used to accrete the contractual service margin, while the current curve is used to remeasure the liability, and the difference is disclosed as insurance finance income or expense.

How is an IFRS 17 close made auditable? #

Every closing balance is regenerated from a pinned assumption set, named curve versions, and a deterministic cohort mapping, and each period’s inputs and outputs are fingerprinted and chained so a restatement is a new referenced record rather than an edit. The movement analysis, assumption versions, and curve snapshots are then bundled into a package an auditor can reconstruct without access to the running system.