Sub-100ms Lender Routing — How It Works

THE PROBLEM

Real-time APIs are not real-time

Every API call to a lender router costs 200–800ms. On a busy Saturday, those calls time out. Your deal sits in limbo. Your tech stack bloats with fallback logic. Worse: vendor APIs train on aggregate data, not your wins and losses.

⏱️

Latency Tax

200–800ms per call adds seconds to your desk experience and creates timeouts.

📡

Vendor Downtime

When their servers are down, your entire routing engine is down.

Blind Data

Real-time routers learn from everyone. They don't know your lender wins and losses.

ARCHITECTURE

How Louie Routes Faster Than Real-Time

Three-layer system: cache, inference, and feedback loop.

┌───────────────────────────────────────────────────┐
│         DEAL SUBMITTED AT THE DESK (LIVE)         │
└───────────────────────────────────────────────────┘
                          ↓
       ┌─ LOCAL ROUTING CACHE ─┐
       │ (SQLite on your box) │
       │ • Lender matrix     │
       │ • FICO bands        │
       │ • LTV tiers         │
       │ • Vehicle type      │
       │ • Weights (scores)  │
       └─────────────────────────┘
                  ↓ <100ms lookup
        ┌─ INSTANT RANKING ─┐
        │ Top 3 lenders     │
        │ sorted by fit     │
        │ NO API CALLS      │
        └───────────────────┘
                  ↓
       Desk sees result in ~50ms
           (purely local I/O)
                  ↓
┌─────────────────────────────────────────────────┐
│  DEAL OUTCOME LOGGED LIVE (Approval/Decline)   │
└─────────────────────────────────────────────────┘
                  ↓
   ┌─ NIGHTLY REWEIGHT JOB ─┐
   │ (After close-of-business) │
   │ • Fetch all outcomes      │
   │ • Recalculate scores      │
   │ • Update local cache      │
   │ • Closed-loop learning    │
   └──────────────────────────┘

Translation: Your lender weight scores sit on disk in a local SQLite database, keyed by lender and refreshed with a same-FICO-band adjustment layered on at request time. When a deal lands on the desk, Louie does a simple lookup against that cache and ranks lenders by score. No network. No API retry logic. No timeout handlers. The answer arrives fast, every single time, even if the internet goes down.

Why it works: Lender outcomes are deterministic. A 750 FICO customer buying a $15k sedan will get approved by the same lender 95% of the time. You don't need real-time APIs. You need accurate history. Louie learns from your deals. Every week, the system gets smarter because it has new data from your wins.

BENEFITS

Six Reasons This Wins

Built for the real world, not benchmarks.

Sub-100ms Latency

Local SQLite lookup. No network. No cache misses. Every lookup is faster than a Twilio SMS.

🛡️

Zero Vendor Downtime

If a real-time API vendor goes down. If a lender's API is slow. If your ISP hiccups. Your routing still works. Nothing to fail.

🧠

Learns from Your Data

Real-time APIs train on everyone. Louie trains on you. Your lender winners, your edge cases, your wins.

📉

No Per-Call Pricing

Real-time routers bill per lookup or per deal. Louie's routing is flat-rate. Route 10 deals or 1,000. Same price.

🔬

Closed-Loop Learning

Every lender outcome (approval, decline, counter) feeds the nightly reweight. Your scoring gets smarter every day.

Immune to Market Noise

Real-time APIs can't distinguish signal from noise. Louie learns your baseline. A 700 FICO here isn't a 700 FICO across town.

HEAD TO HEAD

Louie vs. Real-Time APIs

How local routing stacks up.

Metric	Louie (Local Cache)	Real-Time API (legacy CRM tools, etc.)
Lookup latency	50–100ms	200–800ms
Uptime guarantee	✓ 99.99% (local)	~99% (vendor-dependent)
API timeouts	✓ Zero (no API)	Common on busy days
Learning data source	✓ Your deals only	All customers (generic)
Vendor downtime impact	✓ Zero	Complete failure
Per-deal cost	✓ Flat-rate license	$0.50–$5 per lookup
Reweight cadence	✓ Nightly (latest data)	Weekly or monthly
Requires fallback logic	✓ No	Yes (timeout handlers)

UNDER THE HOOD

The Lookup Pattern

How your integration calls the routing cache.

JavaScript / Node.js Example

async function getWeights(dealershipId, fico) {
  // deal = { fico: 750, dealershipId: 'default' }

  // Read the cached per-lender scores (nightly reweight already populated these)
  const rows = await db.all(`
    SELECT lender, score, approval_pct, avg_dtf, n
    FROM lender_weight_cache
    WHERE dealership_id = ?
  `, [dealershipId]);

  // Layer a same-FICO-band adjustment on top for this one deal
  const weights = await applyFicoSegment(rows, fico);

  // Rank by score: 0.7 × approval rate + 0.3 × funding speed
  return rankByScore(weights);
}

WHAT'S IN THE CACHE

lender_weight_cache table, updated nightly:

• Lender name
• Approval rate + average days-to-fund (learned from your outcomes)
• Weight / score (reweighted nightly: 70% approval rate, 30% funding speed)
• Same-FICO-band adjustment layered on per deal, not baked into the nightly snapshot

CONTINUOUS LEARNING

The Nightly Reweight Job

How Louie learns from your lender outcomes.

Every night at 1:30 AM:

1. Fetch Outcomes

Collect all lender decisions from the past 24h: approvals, declines, counters, funded deals.

🧮

2. Recalculate Scores

For each lender × FICO band × LTV bucket: approval % = wins / (wins + losses).

3. Rerank Lenders

Lenders with higher approval rates in your FICO band move up. Losers drop down.

💾

4. Update Cache

New scores written to your local routing-cache.db. Desk sees new rankings immediately.

CLOSED-LOOP EXAMPLE

Day 1: You route a 720 FICO deal to LenderA (score 8.2) and LenderB (score 7.1). Both approve.

Day 8 (nightly job): System sees LenderA won 12/15 in your 700–750 FICO band, LenderB won 8/15. LenderA's score jumps to 8.8, LenderB drops to 6.9.

Day 9: Next 720 FICO deal? LenderA now ranks first automatically. No human intervention. No API call. Pure math.

Sub-100ms Lender Routing
Never Slow Down

Real-time APIs are not real-time

How Louie Routes Faster Than Real-Time

Six Reasons This Wins

Louie vs. Real-Time APIs

The Lookup Pattern

The Nightly Reweight Job

Ready to Route Faster?

Sub-100ms Lender RoutingNever Slow Down

Real-time APIs are not real-time

How Louie Routes Faster Than Real-Time

Six Reasons This Wins

Louie vs. Real-Time APIs

The Lookup Pattern

The Nightly Reweight Job

Ready to Route Faster?

Sub-100ms Lender Routing
Never Slow Down