Resources

Guides and ideas for building financial products people can trust

Whether you’re comparing vendors, planning an integration, or making the case to your compliance team, there’s something here written for you. And we hold our writing to the same standard as our product: real sources, no invented statistics, and every claim about a model you can check against its published spec.

Start here

New here? These four are the best places to get your bearings.

The Concordance Manifesto

For decades, financial software has been graded on whether the number looks right. We think users — and regulators — now deserve to see why it's right.

The Five-Minute Quickstart, Annotated

One POST, one JSON response — and a plain-English explanation of every field that comes back, including the ones worth storing.

The Vendor Due-Diligence Questionnaire, Answered

Every procurement process asks roughly the same ten questions. Here are our actual answers, each backed by something you can check — including the ones where the honest answer is “not yet.”

The Checkable-Computation Layer for Financial Software

The industry has been building a category without naming it. This essay names it: what the checkable-computation layer is, what belongs in it, and where it ends.

Foundations

Why we believe financial numbers should be computed, cited, and checkable — and what that actually looks like.

The Concordance Manifesto

For decades, financial software has been graded on whether the number looks right. We think users — and regulators — now deserve to see why it's right.

Calculator, Model, Engine, Spec: A Working Vocabulary

Calculator, model, engine, spec — the industry uses these four words interchangeably. We don't, and the differences turn out to matter.

Six Answers a Financial UI Should Be Able to Give

If someone questions a number in your product, can you show them where it came from? Here are the six answers a financial UI should always have ready.

Table Stakes vs. Moat: Deciding What to Build In-House

Is that calculator your competitive edge, or just plumbing? Eight honest questions to help you decide what deserves your team's time.

The Hidden Cost of a Simple Retirement Calculator

The formula fits on a napkin. The edge cases, the annual updates, and the years of maintenance? Not so much.

Approximation vs. Computation: Why LLMs Should Not Do Your Arithmetic

Language models predict; your users assume the number is exact. Here's why that gap matters, and what to do about it.

The Glass Box Principle

A black box asks users to take the answer on faith. A glass box lets them follow every claim back to its source. We think the choice is easy.

Financial Trust Signals, Ranked

What do users, regulators, and reviewers actually check before they trust a number? Twelve signals, ranked by how much weight they really carry.

Buy-vs-Build Worksheet for Financial Calculators

A worksheet for putting real dollars on the build-vs-buy question — including the maintenance costs that rarely make it into the estimate.

A Short History of Building Calculators In-House

Every generation of financial software has rebuilt the same calculators from scratch. Here's how the pattern took hold, and why it's finally breaking.

Model catalog

A closer look at the models we ship: what each one computes, what it assumes, and what it deliberately leaves alone.

Refinance Break-Even, Explained From the Spec

Seven inputs, one practical question: will the lower rate pay for its closing costs before you move? A walk through the model, straight from the spec.

The FIRE Model: What Financial Independence Actually Means in Code

What does financial independence actually mean once you have to write it in code? A withdrawal rate, a target multiple, and a spec that's honest about its limits.

Social Security Timing: Three Claiming Ages, Honestly Compared

Claim at 62, at full retirement age, or at 70? The model compares all three honestly — formulas published, assumptions stated, exclusions named.

Rent vs. Buy Is a Net-Worth Race, and the Model Runs It Openly

Rent versus buy isn't a monthly-payment comparison — it's a net-worth race. This model runs it in the open, one year at a time.

The Loans & Credit Pack: Eight Models and the Cent That Mattered

Eight loan models, one verification standard — and the story of a rounding bug our own review caught before any user ever saw it.

Equity Compensation: Three Models, Scoped to What Ships

RSUs, ESPP, and the mega-backdoor Roth: three equity-comp models that tell you their boundaries before they show you the math.

Roth vs. Traditional: A Break-Even Model, Not an Opinion

Roth or traditional is really a question about marginal tax rates, not philosophy. The model treats it that way.

Long-Term Care: Insure or Self-Insure, With the Assumptions Visible

This model doesn't price a policy. It compares the quote in your hand against carrying the risk yourself — which is the decision people actually face.

The Emergency Fund Model Solves for Time, Not Guilt

Given what you can realistically save each month, when will your buffer actually exist? That's a question people act on — unlike a guilt-inducing target number.

HSA Contribution Limits, Registry Facts, and the Model on the Roadmap

The HSA contribution limits are in our registry today; the projection model is still on the roadmap. Here's exactly where that line sits, so nobody confuses the two.

Engineering & integration

From your first API call to production — versioning, error handling, and knowing when something's off.

The Five-Minute Quickstart, Annotated

One POST, one JSON response — and a plain-English explanation of every field that comes back, including the ones worth storing.

Embedding a Concordance-Tested Calculator With One Script Tag

A div, a script tag, and you have a calculator whose math you can cite. What the embed does, what it deliberately doesn't, and where the attribution goes.

Version Pinning in CI: Failing the Build When Behavior Would Drift

Pin a test fixture to a spec version and a hash, and “the vendor changed something” becomes a red build instead of a production incident.

Storing the SHA-256 Envelope: A Data-Model Pattern

Five database columns turn every answer your product shows into evidence you can produce later. The schema, plus the retention logic to go with it.

Handling Out-of-Range Errors Gracefully

The API rejects out-of-range inputs rather than quietly adjusting them. Your UI's job is to turn that rejection into helpful guidance, not a wall.

Backfilling a Legacy Calculator With a Concordance-Tested Engine

Replacing math nobody fully remembers writing? Shadow mode, a diff harness, and a cutover you can defend to anyone who asks.

Rate Limits and What Is Actually Metered

One enforced backstop, no run quota at all, and a meter that counts stored households rather than calls. What to build against, and what not to bother building.

Observability for Embedded Math: What to Log and What to Alert On

Five metrics tell you whether your embedded calculation layer is healthy — and the response envelope already carries all five, if your logging keeps the right fields.

The Integration Preflight Checklist

Thirty-three checks across six areas — everything our integration guides recommend, condensed into one runnable list. If every box checks, your integration is boring. That's the goal.

Migration Guide: Replacing a Homegrown Retirement Calculator

The shadow-diff-cutover pattern, applied to the messiest case we know: a retirement tool with years of history and units nobody wrote down.

MCP & AI assistants

How to give an AI assistant real math to lean on, and how to prove it actually used it.

Connecting an Assistant to Worthune's MCP Server

One endpoint, six tools that need no key, and a whole household projection an assistant can run without an account. Here's how to connect any MCP-capable client, tool by tool.

The Evidence Grid: Tool-Backed Numbers vs. Remembered Numbers

What happens when an assistant answers from memory instead of using a tool? We lined up real tool output against two years of constant drift so you can see for yourself.

Designing an Assistant That Cites Its Spec Version

The prompt patterns, response templates, and refusal behaviors that make an assistant's numeric answers reproducible instead of merely plausible.

Tool-Call Traces as Audit Artifacts

A conversation is testimony; a trace is evidence. How to store your assistant's tool calls so that every number it ever gave can be traced back to a computation.

Curating the Tool Surface for a Financial Assistant

Our catalog offers dozens of models — your assistant probably shouldn't offer all of them. How to choose, describe, and stage the tools it can reach.

Red-Team Prompts for Financial Assistants

Twenty-five adversarial prompts every deployed financial assistant should be able to pass. Deliberately generic, so the list outlives any single vendor.

MCP or REST: Choosing a Transport for Assistant Math

Same engine, same response, two ways in. The real question is who owns the tool loop — the assistant client or your backend — and what each one can promise.

Guardrails: Why Refusing to Answer Beats Guessing a Contribution Limit

When an assistant doesn't know a contribution limit, a good refusal beats a confident guess. The craft is making that refusal specific enough to be useful.

Grounding Constant Questions: Assistants and the Facts Endpoint

“What's the 401(k) limit this year?” isn't a computation — it's a lookup, and it deserves the same care. Two grounded ways to answer the questions models most often get wrong.

Eval Datasets for AI Teams: Ground Truth You Did Not Have to Build

250 test cases per model, agreed by two implementations written independently from the published spec. What's in the datasets, which ones are public, and how to turn them into a benchmark for your assistant.

Compliance & auditability

For regulated teams: the records, the review workflows, and the audit trail behind every number.

SR 11-7 and the Concordance-Tested Stack: A Mapping for Model-Risk Teams

The 2011 model-risk guidance predates every calculator API, but its vocabulary maps surprisingly well onto published specs and Concordance testing. Here's the mapping — and where your obligations remain your own.

The Envelope as a Books-and-Records Object

Broker-dealers keep records under Rule 17a-4; advisers under Rule 204-2. The response envelope works as a record under both — as long as your storage layer holds up its half.

Fair and Balanced, Computed: Calculators as Retail Communications

FINRA Rule 2210 asks whether a communication is fair, balanced, and not misleading. A calculator can answer with its stated assumptions — if your integration keeps them visible.

The UDAAP Lens on Silent Clamping

A calculator that quietly adjusts your inputs is answering a question about someone else's situation. Consumer-protection law has words for that — and there's an engineering pattern that never does it.

Answering "Why Did It Say That?": The Replay Procedure

A user disputes a number. A reviewer samples one. An examiner asks about one. The same five-step replay procedure answers all three.

The Annual Model Review, Run on Published Artifacts

One afternoon a year per model family, a short memo at the end, and every input an artifact you can open. The routine that keeps “reviewed” from meaning “reviewed once.”

The Vendor Due-Diligence Questionnaire, Answered

Every procurement process asks roughly the same ten questions. Here are our actual answers, each backed by something you can check — including the ones where the honest answer is “not yet.”

Change Control You Can Read: Versioning as Governance Evidence

Change management usually lives in tickets nobody outside the vendor ever sees. A public, versioned changelog turns it into governance evidence — and a recent release shows the whole thing working.

Planning Aids, Not Illustrations: The Insurance Boundary

State insurance law is strict about what an “illustration” may show. Our insurance-adjacent models stay firmly on the planning side of that line — here's where it sits, and who owns what.

A One-Page Compliance Map of the Worthune Platform

Every artifact a reviewer will ask about, the URL where it lives, and the obligation it usually serves. Worth bookmarking if compliance is your job.

Comparisons

Build it, buy it, or blend the two? The honest trade-offs, one decision at a time.

Concordance-Tested API vs. Homegrown Calculator

The comparison isn't really about the arithmetic — it's about everything that has to stay true around the arithmetic. Six dimensions to weigh.

Embed Widgets vs. Backend API vs. MCP

Embed widget, backend API, or MCP? Three ways to put Concordance-tested math on a product surface, and how to pick the one that fits yours.

Deterministic Models vs. LLM-Generated Math

There are two ways to produce a number: arithmetic and prediction. The best products know exactly when to use which.

Static Content Calculators vs. Live-Constants Calculators

A number on a page is either bound to a source that updates, or it's quietly drifting. And the gap widens every revision cycle.

Open-Source Financial Libraries vs. a Maintained Registry

Open-source libraries and maintained registries are both valid choices. The real question is who owns the maintenance calendar.

White-Label Planning Suites vs. Composable Models

An all-in-one suite hands you a finished UI; composable models hand you a catalog. Both are legitimate — it comes down to who should own the top layer.

Powered-by Attribution vs. White-Label: A Cost Tradeoff

A visible “powered by” badge is a real cost to some brands and a real benefit to others. It depends on who your end user is and what they should see.

Compliance-Owned Copy vs. Model-Cited Answers

Two ways to defend a number in front of a customer: compliance-approved copy, or an answer that cites its model. Which artifact should carry the weight?

US vs. Global Financial Calculators: Why This Product Starts Domestic

Regulatory surfaces, constant registries, and data quality vary enormously across countries. Starting US-only is a scope decision, not a shortcoming.

Freemium APIs in Fintech: What Free-With-Attribution Actually Means

“Free” means very different things across fintech APIs. What matters is how durably each vendor commits to what free means — and how you'd tell.

Vertical playbooks

How this works in your corner of the industry — advisor platforms, banks, credit unions, and more.

Advisor-Platform Playbook: Concordance-Tested Math Under the Advice

Advisors own the recommendation; the platform should own the arithmetic underneath it. The integration pattern for advisor software, from model selection to the record in the client file.

Brokerage and Wealth-App Playbook: Calculators Under Communications Rules

Retail brokerages ship calculators into the most rule-dense communications environment in consumer finance. Here's how to make those tools genuinely reviewable — not just reviewable in theory.

Digital-Banking Playbook: The Lending and Savings Surfaces

Banks run some of the most-used calculators on the web, and keeping them current is a constant struggle. The integration pattern for digital banking teams, with the UDAAP discipline built in.

PFM-App Playbook: From Insight Feed to Checkable Answer

Personal-finance apps are great at showing people their money, and weaker at answering “so what should I do?” Here's how to turn insights into real computations — no quant team required.

Benefits-Platform Playbook: Open Enrollment Without Stale Numbers

Every fall, every limit moves, and every enrollment page has to be right on day one. The integration that finally makes that calendar boring.

Accounting-Practice Playbook: Advisory Conversations, Computed

Advisory work runs on scenario arithmetic. The integration pattern for CPA practices and the platforms that serve them — with the tax-prep boundary kept clean.

Lender Playbook: Education Surfaces That Never Touch the Rate Sheet

Lenders need borrower education that builds trust without turning into a quote. Here's how to keep the calculator layer and the rate sheet strictly apart.

Credit-Union Playbook: The Script-Tag Path to a Concordance-Tested Calculator Suite

Big-bank member expectations, community-institution budgets. How a credit union can ship a full Concordance-tested calculator suite with two lines of markup per page — free, with attribution.

Personal-Finance Media Playbook: Interactive Tools That Won’t Age Out

For editorial teams, the numbers age faster than the articles do. Here's what an evergreen tool strategy looks like when the numbers stop aging.

Financial-Coaching Platform Playbook: Assessments Backed by Models

Coaching products run on assessments and behavioral framing. Concordance-tested models are what make the arithmetic inside those assessments real.

Toolkits

Checklists and worksheets your team can put to work this week.

Financial Calculator Launch Checklist

Thirty-nine items across product, engineering, compliance, marketing, and support — what a shipped calculator looks like when nothing got skipped.

Content Refresh Checklist for Tax-Year Rollover

The checklist every editor should walk each October and November — before a page quietly serves last year's numbers all year long.

Model Card Worksheet

One page, twelve fields, per calculator. Enough for a reviewer to understand in five minutes what the tool actually does.

Calculator UX Heuristics: Score Your Current Tool

Fifteen heuristics for scoring your current calculator. Score it honestly, then fix from the top.

"What Should We Embed First?" Decision Wizard

Six questions that point you to the calculator most worth adding to your product first.

Attribution Audit Worksheet

Where the badge needs to appear, and in what form. An hour of auditing that prevents most attribution failures.

Vendor Risk Interview Kit for Model Vendors

Ten questions to ask any model vendor before you sign. Good answers look alike — what varies is whether the vendor can produce them at all.

Retirement Planner Feature Coverage Checklist

The edge cases a serious retirement planner has to handle. Check your current tool against the list, then fix the gaps that matter for your audience.

Mortgage Tool Feature Coverage Checklist

Every feature a real mortgage tool might need. The gap between this list and your tool is where users give up and leave.

Financial Content Fact-Check Worksheet

Constant, source URL, revision date, spec version — ten minutes per article before publish, hours saved every time it ages.

Facts & reference

The constants behind the math, and exactly where every one of them comes from.

Anatomy of a Facts Registry Row

Nine fields turn a tax constant from a number in code into a claim you can check. This is the registry our models actually read — published from the same file the engine imports.

The TY2026 Constants, Mapped to Their Source Documents

Three IRS documents set almost every 2026 number a financial calculator needs — and they arrive on two different calendars. Here's the map, with the registry values alongside.

Social Security Claiming Factors: What the Registry Holds and What It Does Not

Two reference factors, the reduction formulas behind them, and a deliberately short list — plus the repealed rules a registry has to remember without ever applying.

What Worthune Deliberately Does Not Model

Credit pricing, insurance underwriting, market forecasts — a catalog of things we deliberately don't model, each with its reason. Scope you can read is scope you can trust.

US-Federal Only: Why the Registry Stops at State Lines

Fifty state tax codes, one exact jurisdiction field. Why the registry stops at state lines, and what to do on the other side of them.

The Uniform Lifetime Table, as a Maintained Artifact

Forty-eight divisors from IRS Publication 590-B drive every RMD computation. How the table lives in the registry — and why the last row reads “120 and over.”

Reading Worthune's Public Telemetry

One URL shows our own traffic: daily hits per surface, thirty days deep, aggregates only. What the fields mean, and what the endpoint deliberately can't tell you.

How to Read the Model Changelog

Every behavior change lands as a versioned, dated entry generated straight from the specs. A reading guide, with a real entry unpacked.

Reproducing a Model From Its Spec: The Eval Datasets

Every model ships with 250 Concordance cases — the same ones our CI runs, with the sample models' datasets fully public. How to get a set, what the tolerance means, and what reproducing it proves.

The Verified-On Date: Freshness as a First-Class Field

Constants are claims, and claims age. Why every registry row carries the date a human last checked it — and what an honest public correction looks like.

Buyer & leadership

The executive view: what this costs, what it saves, and why it holds up over time.