Loan Pricer is the platform's pricing engine — the brain that takes a loan scenario and answers two questions in sequence: does this loan qualify, and at what price? A Program Engine decides eligibility across every subscribed program; a Pricing Engine then computes and ranks true best execution across the options that qualified. The same machinery runs a single interactive quote or thousands of loans in a batch.
A full, multi-page site devoted entirely to the program & pricing engine — its search modes, performance, mobile experience, and ownership options. One of the flagship product domains we own; this page is just the overview.
Explore LoanPricer.com →Measured performance, and the data layer beneath it.
Eligibility and price are kept strictly separate, and the flow never reverses.
Narrows from every program the lender is subscribed to down to the exact program-and-product combinations the borrower is eligible for. It decides eligibility only — it never touches price.
Takes only what already qualified, builds each option's final rate and price, and ranks the results by best execution. It prices what passed — it never re-decides eligibility.
This clean separation means each engine has a single responsibility, the eligibility decision is fully auditable on its own, and the same priced results can be re-ranked without re-running guideline logic.
Open any stage, then walk the whole pipeline with Prev / Next.
The single hardest question about owning a pricing engine — answered. For any loan, even one priced months ago, the engine replays its evaluation field by field off a saved execution log and attributes every outcome to a specific cause: a published guideline, an overlay rule (with the exact condition that fired), or the input data. "The loan did something unexpected" becomes "this field failed because of this rule" — a defensible, repeatable answer instead of a guess.
The architecture a technical evaluator will want to see.
The Program Engine is a Chain-of-Responsibility assembled by a factory, each executor handling one stage and passing an accumulating scenario forward. Program inheritance (shell programs drawing sections from root programs) is resolved entirely in the data layer, so the executors stay inheritance-unaware.
All data access is stored-procedure-based via Dapper. The ratesheet base grid is the platform's largest dataset — investor rate sheets push well over a million rows per day — so the pricing data layer is deliberately tuned to evaluate only the records that can apply to a given loan.
Loan Pricer owns the loan tables: a parent header plus nine system-versioned temporal child tables that retain full per-facet history automatically. Every run serializes its scenario to an executor log, which the audit screen re-opens to replay eligibility in a no-write mode for repeatable, field-by-field diagnosis.
For Non-QM scenarios, the borrower's credit events and mortgage lates are graded, and the resulting credit profile filters eligibility to the credit-approved programs before pricing ever runs — credit shaping the result, not bolted on after it.
Beyond rate and price, the engine resolves each option's ARM margin and rate caps and its prepayment terms — so an adjustable-rate loan is priced as the instrument it actually is. The kind of domain depth only an industry veteran would build in.
Guidelines and overlays are authored visually as data and bound to live loan fields at evaluation time — one authoring tool drives both engines. A lender reshapes eligibility and pricing behavior through configuration, with no deployment.
The same engines power the interactive quote and the institutional-scale Bulk Pricer.
Request Private AccessA guided loan-entry form where a loan officer builds one valid pricing scenario and submits it with a single click.
Officers start a new scenario or reprocess a saved loan, entering originator, loan category, property, and borrower profile across three validated tabs. Cascading dropdowns ensure only programs the client is subscribed to appear, and fields auto-calculate and auto-geocode so a user can only build a valid request. One Submit runs the eligibility engine and routes to the correct next screen.
A six-stage pipeline that narrows from every subscribed program down to the exact program-and-product combinations the loan is eligible for.
Built as a chain of responsibility, each stage hands an accumulating scenario to the next: setup/enrich, categorical match, numeric match, product match, overlay application, and outcome. Overlays are scenario-specific restrictions that can only tighten a program's published guideline, never loosen it. The engine decides eligibility only — it never touches price.
Takes each eligible program-and-product pair, builds its final rate and price, and ranks the results by best execution.
A named-stage flow looks up base pricing, applies loan-level and servicing adjustments, applies post-adjustment overlays, resolves the lock window, then ranks every result so the strongest options surface first. It prices only what already qualified, and runs full-matrix for interactive quoting or single-rate for high-volume batches.
The payoff screen: a rate-by-product grid showing the best available price across every qualifying program.
Rates run down the side and products across the top; each cell holds the best price any qualifying program offers at that rate-and-product. Officers click any cell to see its full breakdown, compare alternative programs at the same rate, change the lock window to re-price, and request a rate lock that snapshots the selected price.
When a loan doesn't fit as submitted — or the officer shopped for a maximum — the engine returns ranked options instead of a single price.
If nothing qualifies as entered, the engine relaxes one constraint and re-runs once to surface the best terms actually available; if the officer left a field blank to shop a maximum, this is the requested exploration of that limit. Options arrive ranked best-first; the officer dials in the borrower's actual values, which recompute the tiers live, then continues to pricing.
The troubleshooting front door: every program listed Pass or Fail, with a field-by-field reconstruction of exactly why.
Because the engine evaluates dozens of programs against thousands of guideline and overlay rules, Loan Audit is how a user finds the cause of any unexpected result. Clicking a program replays the eligibility pipeline in a no-write audit mode off the loan's saved execution log, reporting the first field that disqualified it and whether the limit came from a guideline or an overlay.