Built to scale to a Generali-sized portfolio
This prototype runs the real scoring engine described below end-to-end against a synthetic fleet. The architecture is the same one that scales from a 100-vehicle pilot to a multi-million-policy portfolio — only the data sources at the edges change.
System architecture
Four layers, each independently scalable and independently testable.
Design principles
Every telemetry source (OBD/CAN, GPS, driver app, claims, weather) lands on an append-only event bus (Kafka/Kinesis-class). Producers and consumers scale independently, so onboarding a new OEM/telematics vendor or a new insurer's claims feed never touches the scoring path.
SafeGuard, RapidRate, ClaimSense and PredictEdge (lib/engine in this prototype) are pure functions over a feature vector. In production they run as horizontally-scaled stateless services behind an API gateway — scale is linear with fleet size, not with model complexity.
Raw signals are aggregated once into a shared online/offline feature store. The dashboard, the pricing engine and the claims-fraud model all read the same driver/vehicle/route features, so scores stay consistent across every surface.
Every record carries a tenant (insurer/broker/fleet) and policy-scope key from ingestion through to the API. Row-level isolation plus per-tenant encryption keys let Parametriks serve Generali's captive, a broker panel and a direct fleet client from one platform without data crossing boundaries.
Every score already carries its contributing factors (see the behavioural breakdown in the live dashboard). That is not a UI add-on — it's how the engine is written: weighted, named sub-scores, never an opaque black-box output. This is what actuarial and compliance sign-off requires.
The engine recommends (coach driver, adjust premium, trigger maintenance, investigate fraud); it does not auto-execute against policy or bank systems. Every action routes through the insurer's existing underwriting/claims workflow and audit trail.
Odometer reading and condition photos are captured before a vehicle goes to a driver, timestamped and stored against that vehicle's record. This is the same evidentiary logic as the ClaimSense liability-dispute reduction — an objective initial-state record beats a disputed memory when a damage claim is filed.
Compliance & risk posture
Rollout plan
Claims-history + one live telemetry source (GPS or OBD) on a bounded pilot fleet. Validate score calibration against Generali's actual loss data.
Add remaining data layers, stand up the feature store and event bus for full fleet volume, integrate RapidRate into underwriting workflow.
ClaimSense fraud detection live on claims intake, PredictEdge portfolio reporting for reserving, broker-facing risk-improvement reporting.
This prototype, technically
Next.js 14 (App Router) + TypeScript end to end. The scoring engine (lib/engine) is framework-agnostic and unit-testable in isolation — it is the same code the API routes and the server-rendered pages call. Synthetic fleet data is deterministically generated (lib/data) so every score, chart and premium figure on this site is a real computation, not a hardcoded mock. Swapping the generator for live OBD/GPS/claims ingestion does not require changing any downstream component.