Limen v0.1

Limen — Why It Exists The Problem Insurance core systems are still largely built on 20–40 year old assumptions. They treat a policy as a collection of database rows that must be joined together at runtime. They treat money as mutable balances that get updated in place. They bury business rules in code or database triggers. They force life, short-term, credit life, and specialty products into separate systems or heavily forked codebases. They rely on month-end batches and overnight runs. They make change slow, expensive, and dangerous. The result is familiar:

New products take months (sometimes years) to launch Simple mid-term changes create risk and manual work Reporting and IFRS 17 become multi-year programmes Performance collapses under real volume Actuaries and operations are dependent on IT for almost every rule change Migrating off a legacy platform is treated as a multi-year, multi-million-dollar event with high failure rates

These are not minor inconveniences. They are structural limitations of the current generation of policy administration systems.

What Limen Is Limen is the operating system for risk. It is not another Policy Administration System that tries to be slightly better at the old game. It is a fundamental redesign of how insurance contracts, money, time, and decisions are represented and executed. At its core Limen treats:

A contract as a versioned, fully hydrated document (not a web of joins) Money as an immutable sequence of events (never updated in place) Business rules as versioned, actuary-owned decision models (DMN) Time as a first-class concept (escalations, terms, cascades, recognition) Any insurable risk (life, funeral, motor, credit, group, on-demand, etc.) as the same underlying model with different configuration

What Limen Solves 1. Speed of change Product and rule changes move from code releases to decision model deployments. Actuaries and product people can move faster without waiting for development cycles. 2. Performance at scale Active policy state lives in memory-local form. Financial writes are append-only and contention-free. The system is designed for sub-millisecond reads on the hot path and high write throughput on money. 3. One platform, many lines Life, short-term, credit life, group, and specialty risks run on the same core engines. No more separate systems that have to be integrated after the fact. 4. True history and auditability Every structural change creates a new version. Every financial movement is an immutable entry. Back-dated corrections create explicit forks and compensating entries instead of rewriting the past. 5. Operational simplicity under complexity The real complexity of insurance (layers, multi-subject covers, dependencies, different escalation bases, cover term vs premium term, etc.) is modelled explicitly so the system remains predictable instead of accumulating special cases. 6. Modern deployment and compliance Cellular multi-tenancy supports data residency requirements (POPIA and equivalents) while still allowing uniform deployment of code and rules.

Why It Will Be Next to None Most “modern” insurance platforms are still evolutionary. They put better interfaces and some cloud infrastructure on top of essentially the same relational, mutable, batch-oriented core. Limen starts from different first principles:

Data locality instead of joins Append-only money instead of mutable balances Decision models instead of buried logic Temporal versioning instead of overwrite history One coherent model instead of product-line silos Clean Architecture and strict boundaries so the system can evolve without collapsing under its own weight

The combination produces a platform that is simultaneously:

Faster to change Faster at runtime More auditable Capable of handling real product complexity Designed for the regulatory and operational realities of multiple markets

That is the gap Limen exists to close. It is not trying to be a better version of the old PAS. It is trying to become the layer that modern insurance runs on.

One-line truth Risk is just data. Most systems still treat it like paperwork. Limen treats it like data — precisely, versioned, and at speed.