Clarity IUL
When constraints become the architecture
Role: Lead Designer & Builder
Company: Inception Financial Services
Domain: Fintech / Compliance Tools
Built with: Claude AI • 2026
Download demo data and upload to the policy illustration to test
The Brief
The regulation told us what to build. The constraint told us how.
Insurance regulations require IUL illustration software to show clients a single compliant scenario — no crash sequences, no probability distributions, no stress tests. The rules protect consumers from inflated projections, but create a blind spot: advisors had no tool to show what those illustrations couldn't. Inception Financial Services needed a simulator that went where carrier software was forbidden to go.
The second constraint arrived with the brief: no client data could ever touch a server. Every simulation, every report had to live and die entirely within the user's browser.
Most teams would treat these as separate problems. I read them as one. A zero-server architecture is simultaneously free to exceed regulatory illustration limits and structurally incapable of creating the data liability that would make doing so problematic. The constraint didn't limit the solution — it became the solution.
Regulated software shows advisors what the law allows them to say. This tool shows them what they actually need to know.
• The Single-Scenario Illusion
Compliant illustrations show one path. Advisors had no way to present a probability distribution — or the scenarios where the policy fails.
• No Stress Testing
Carrier software cannot model a 1973 stagflation sequence or a 2008 crash at retirement age — the exact scenarios advisors need before recommending a distribution strategy.
• No Comparison Framework
No rigorous way to show how IUL performs against a taxable brokerage or IRA across the same return sequence — the only fair test of tax treatment.
• No Firm Infrastructure
No system for standardizing analysis across a firm, reviewing advisor sessions, or delivering consistent client-facing output.
The Architecture Decision
One decision that answered both constraints at once
The Architecture Principle
One deployable HTML file per firm. All simulation logic, crediting models, IRS §7702 corridor calculations, and export generation run entirely in the browser. No client data crosses a network boundary — compliance guaranteed by construction, not by policy.
From that single decision, every downstream challenge had a clear resolution. Session state became a portable JSON file the advisor owns — replacing the database and doubling as the compliance audit trail. PDF reports, firm branding, and authentication all run in-browser. ~24,000 Monte Carlo iterations execute in seconds without a server call.
Each constraint solved well became a feature. The JSON export is how firm owners review advisor work. The per-firm HTML file is how new clients are provisioned in minutes. And the zero-server architecture is the one line of copy advisors lead with in a skeptical client meeting: no data is ever sent to any server.
A constraint that eliminates a liability is not a limitation. It's a product promise.
Built with AI • Claude-powered development
Design as direction, AI as implementation
I built this platform in direct collaboration with Claude — not as a shortcut, but as a methodology. My role was to hold the product vision and specify behavior with enough precision that AI could implement it faithfully. That discipline changed the work: ambiguity that would normally surface in a sprint review had to be resolved in the brief. Every well-specified decision shipped immediately. Every gap surfaced visibly. The specification was the design artifact. And the design artifact shipped.
When AI is the implementation layer, the quality of your thinking — not the speed of your execution — becomes the rate-limiting factor.
The Experience
Policy Configuration – Carrier-agnostic by design
Advisors upload their carrier's illustration spreadsheet and the tool auto-detects columns. Nothing is hardcoded — premium loads, surrender charges, crediting parameters, face reduction strategies are all configurable. The tool serves the advisor's data, not the other way around.
When AI is the implementation layer, the quality of your thinking — not the speed of your execution — becomes the rate-limiting factor.
Simulation Engine – ~24,000 futures, rendered in seconds
The Monte Carlo engine draws from a 97-year S&P 500 dataset using historical bootstrap sampling — random 3–5 year return blocks that preserve real crash clustering and bull-market runs. Advisors choose simulation depth and return model; the UI explains what each choice asks the engine to do.
Results Dashboard – Probability, not prediction
The headline isn't a projected value — it's a success rate: the percentage of simulated futures where the policy survives to the target age. A percentile fan chart shows the full distribution. A lapse risk bar turns red when failure probability becomes significant. The failure anatomy histogram shows exactly when lapse events cluster — changing how advisors structure distributions.
Year-by-Year + Sensitivity – Risk visible at every row
A full actuarial table tracks premium, loan, interest, accumulated value, and death benefit year by year — rows shifting from Active to At risk as the loan-to-AV ratio approaches the lapse threshold. Sensitivity analysis then ranks every lever by impact on success rate, surfacing the most actionable change first.
Vehicle Comparison – Same market. Three tax realities.
The comparison module runs an apples-to-apples test — identical return sequence, identical withdrawals — isolating tax treatment as the only variable. At age 90, the median IUL reaches $1,136,821. The taxable brokerage reaches $129,107. The tax-deferred IRA reaches $0, depleted by RMDs and ordinary income tax.
Every screen was designed around a single question: what does this advisor need to say — with confidence — in a client meeting?
Role Architecture
Governance as a design system
Three user tiers, each with a distinct relationship to the platform. The key insight: the super admin is a firm provisioning tool, not a user account. New clients receive a deployable HTML file with identity baked in — no shared system, no user management backend, infinite scale.
• Super admin
Generates firm-specific deployable files with branding and credentials baked in. Invisible to end users. No Stress Testing
• Firm Owner
Manages advisor accounts, reviews exported JSON sessions, resets credentials from the firm dashboard.
• Advisor
Runs simulations, generates branded PDF reports, exports and restores sessions. No visibility into peers' work.
The super admin isn't a user. It's a deployment tool — the distinction that makes the entire permission model scale without a backend.
What shipped
Inception Financial Services launched with a fully white-labeled, multi-firm platform. Advisors moved from single-scenario illustrations to probability distributions across four return models — including historical replays of 1929, 1966, 1973, and 2008. For the first time, they could show clients the full range of outcomes and, critically, which levers change them.
For the first time, advisors could answer the question their clients were actually asking: what are the odds this plan holds?
~24k
Monte Carlo simulations run in-browser, in seconds
97
Years of S&P 500 history — including every crash
0
Client data bytes ever sent to a server
Reflection
Two constraints. One architecture.
The brief arrived with two requirements that seemed unrelated. One was a product ambition: go further than regulated illustration software allows. The other was a compliance mandate: no client data touches a server. The instinct is to solve them separately. The insight was that a zero-server architecture resolves both simultaneously — it's free to exceed regulatory illustration limits precisely because it's structurally incapable of creating a data liability. The constraint that defined the capability and the constraint that governed the data were the same constraint, answered once.
That's what systems thinking means in practice — not integrating components, but finding the abstraction level where separate problems collapse into a single principle. Every downstream decision followed from the architecture. The architecture followed from reading the brief carefully enough.
Building with AI made the quality of that thinking the rate-limiting factor — not execution speed. Every well-specified decision shipped immediately. Every ambiguity surfaced as a gap. The regulation showed us where to build. The constraint showed us how. The architecture made them the same thing.