Every loan runs the same path: decide what qualifies, then price what passed and rank it. Eligibility and price are kept strictly separate, the flow never reverses, and every step is recorded so the result can be defended field by field.
Narrows from every program the lender subscribes 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.
A guided form where an officer builds one valid pricing scenario and submits it with a single click.
Originator, loan category, property, and borrower profile are entered across 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 request that's valid to price. One Submit posts the scenario to the Program Engine.
A pipeline that narrows every subscribed program 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 and enrich, categorical match, numeric match, product match, overlay application, and outcome. Overlays can only tighten a program's published guideline, never loosen it. The output is program×product pairs — not a flat program list — and the engine decides eligibility only.
Takes each eligible 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 ratesheet 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. 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. A display-only price-format toggle never changes the computed number.
A non-fit is a starting point, not a stop. Instead of a financing failure, the engine automatically returns the best achievable terms — ranked.
When a scenario doesn't qualify as entered, the engine relaxes one constraint and re-runs once to surface the best terms actually available — turning a dead-end decline into a real counter-offer the officer can take back to the borrower. (If the officer left a field blank to shop a maximum, this is that requested exploration instead.) Options arrive ranked best-first; the officer dials in the borrower's actual values, which recompute the tiers live, then continues to pricing.
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, the 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.
The feature officers reach for every day. Leave a financial field blank and check Max or Min — instead of pricing a number you typed, the engine searches for the number itself: the largest loan amount, the highest LTV, or the most cash-out the borrower actually qualifies for. Shop two dimensions at once, and the counter-offer stage returns the answer ranked best-first.
It turns "what will this borrower qualify for?" from a guessing game into a single priced run.
One scenario, many questions answered — each mode runs the full Program Engine, so the answer is always what actually qualifies.
Price several products side by side for a direct best-execution comparison — Fixed, ARM, and Interest-Only weighed at a glance.
Solve for every qualifying LTV / CLTV combination — the most leverage the borrower and the programs actually allow.
Solve for the most cash-out the borrower qualifies for — no hand-iterating the loan amount to find the ceiling.
Find the lowest credit score that still qualifies — know exactly how much score headroom a scenario has before it breaks.
Price a first and second lien together as one structured scenario — the combo rendered as paired best-ex grids.
The general form: leave any financial field blank, check Min or Max, and let the engine solve for the number — up to two at once.
The single hardest question about owning a pricing engine. 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.
Qualified parties get private, hands-on access to the live engine — to price a loan and interrogate the result field by field.