Joseph DeMasse

Speed-to-lead is the largest controllable driver of funded volume in this business, and it is decided in the first ninety seconds. Avery owns those ninety seconds at unlimited concurrency: it calls the moment a lead arrives, greets the borrower by name, qualifies intent, captures the opening Form 1003 through ordinary conversation, and warm-transfers only interested borrowers to a licensed officer with the application already filled in. It never quotes a rate and never makes a decision. That boundary is enforced in code, not written in a prompt and hoped for.

The half that matters is underneath. A fail-closed gate clears do-not-call status, calling window, state licensing and recording disclosure before a digit is dialed. Carrier webhooks are verified as Ed25519 signatures over the raw body and rejected outright when they don’t check out — which meant learning that a raw 32-byte key needs an SPKI DER prefix prepended before the runtime will accept it, and that the vendor’s own documentation names the wrong field on the key endpoint.

The call log is the piece I’m most careful about, because it is the artifact that answers a subpoena. Version one wrote its state file in place and swallowed its own errors, so a crash mid-write could destroy the entire history and quietly reseed an empty one. Version two writes atomically and treats an append-only, SHA-256 hash-chained journal as the source of truth: any edit or deletion breaks the chain, and verification names the exact sequence number where it broke. Searchable by phone number, IP and transcript.

It runs unattended on its own cloud host behind automatic TLS, works a live pool of 15,784 leads, and both speech engines draw from that one pool so neither starves.

Underwriting today is a black box that says no. Crucible makes it a glass box that shows the path to yes. Three agents argue over one live loan file: an Adversary that tries to kill it and cites every finding, an Advocate that finds the guideline-valid route around each kill shot, and an Adjudicator that rules on the cited record — abstaining where the evidence is missing — then emits a ranked remediation path alongside the Regulation B adverse-action reasons the borrower is owed either way.

Citations are retrieval-grounded against a Fannie Mae and HUD corpus rather than generated, so a claim that can’t be traced doesn’t ship. A hybrid router keeps cheap and sensitive work on a local GPU and escalates only genuinely hard reasoning to a frontier model, which turns out to be both the cost story and the privacy story. Uploaded documents are classified and auto-clear the conditions they satisfy.

Built for the AMD Developer Hackathon Act II, Unicorn track, and submitted July 2026. Source →

A knowledge engine that runs on hardware we own, because the documents are not allowed to leave it. Astravyx indexes underwriting guidelines, compliance material, internal runbooks, Salesforce metadata and vendor API docs, then answers with citations — and when the answer isn’t in the index it says so instead of inventing one. Retrieval reconfigures across vector, keyword, hybrid and agentic modes depending on the question.

No model reaches users on reputation. A promotion gate scores every candidate against held-out golden sets and blocks the swap if it regresses; groundedness and citation accuracy are measured, not assumed. Anything touching a credit decision passes an ECOA / Regulation B firewall first, and the audit trail records how each answer was produced.

The question was uncomfortable: our incumbent vendor’s dialer was less configured than ours, had no AI, and still got answered far more often. The assumption in the room was cadence, or dial volume, or something in the model. I went looking in our own archive instead — 984,281 stored objects, of which 252,690 turned out to encode the outbound caller ID and agent right there in the filename for a ten-month window before the naming scheme changed to opaque identifiers. That accident is the whole reason the question was answerable at all.

It was none of the things we assumed. They were dialing from 6,406 distinct numbers across 310 area codes. We had 23. Eighty-six percent of theirs were used on a single day and then retired; four hundred to eleven hundred fresh ones were injected every month. Spam labelling is reputation-based, so a number that is one day old has no reputation to have ruined yet. They weren’t avoiding the spam flags — they were outrunning them.

Which inverts the intuition completely: with 23 numbers, dialing more makes penetration worse, because every extra call deepens the reputation damage on the same tiny set. Every sophisticated thing we had built — the cadence engine, the AI, the fail-closed compliance gate — was sitting behind a twenty-three-number-wide front door.

So I built the rotation engine. It holds a target pool of fresh local numbers, plans purchases spread across the least-covered area codes nearest our actual lead geography, and retires numbers the health checker has flagged once they’re past a minimum age. Because it spends real money, it is dry-run unless explicitly confirmed, capped on pool size and purchases per run, and structurally incapable of releasing the aged, branded numbers that carry our inbound and callback traffic — it can only ever retire what it bought itself.

Loan files move from Salesforce into the wholesale lender’s API, and milestone events come back through webhooks into ten tracked date fields. Idempotency and monotonic rules mean a replayed or out-of-order event cannot corrupt a timeline — which sounds academic until a race condition strands eleven live loans. I built the buffering retry that stopped it recurring and the replay script that healed the eleven without anyone re-keying a date.

Conditions, document requirements, automated underwriting and credit pulls all ride the same path. Everything promotes sequentially through sandbox, QA and production with a validation-only deploy before each one. In a two-person Salesforce team the discipline is the only thing standing between you and a Friday outage.

A document hub embedded directly into Salesforce through a Named Credential, so it reads as part of the CRM rather than another tab someone has to remember. It pulls the wholesale lender’s outstanding conditions and reconciles them into a six-bucket working view — what’s needed, what’s submitted, what’s cleared — so processors stop cross-referencing two systems by hand.

Live across all three Salesforce orgs and as a standalone web app on Amplify.

A React app embedded in Salesforce over postMessage through a host Lightning component. It renders the live loan application fields as the voice agent fills them in mid-call, so an officer picking up a warm transfer sees the borrower’s answers appear rather than starting from a blank record.

Getting leads where they need to be, without breaking the dialer. A GUI-driven loader writes campaign lists straight into the dialer’s list configuration, builds rate-drop lists off pipeline criteria, and paces uploads through a throttled drip queue — per list, rather than dumping one enormous bulk job and watching the whole thing back up.

The company’s public site, rebuilt to the brand rather than to a template, with the online mortgage application wired directly into it instead of bouncing applicants to a third-party portal. Consent is gated for TCPA before anything is captured, and an AI assistant backed by our own retrieval engine answers questions on the page. Deployed on Amplify with DNS moved onto Route 53.

A borrower-facing portal talking to Salesforce through a hub API, so document requests, outstanding conditions and loan status all come from the same source of truth the loan officers work in — no second copy to drift.

When it went down, everyone assumed credentials. It was a stale CORS origin on the Lambda after an environment moved. Worth saying because the debugging lesson — check what actually changed before you start resetting things — has saved more time since than the fix itself.

Milestones score points, standings update live in Salesforce and on the web. The part that mattered was integrity: points are voided when a loan cancels or withdraws, so the board can’t be farmed by writing business that never funds. Extended with a 3D avatar and emote store built on a shared skeleton so new characters drop in without new animation work.

A kill-chain runner for infrastructure we own. Scope is an Ed25519-signed authorization the agent verifies before it will touch anything — a target outside the signed scope is refused, not warned about. Reconnaissance, vulnerability lookup, CVE correlation and reporting all run behind that gate, which is the difference between a security tool and a liability.

Watches for third-party changes across our Salesforce orgs, AWS accounts and GitHub repositories, flags anything originating outside a configured trust list, and catches device mismatches on owner logins. The rules are written against behaviour and never against a named person — a distinction worth designing in deliberately rather than defending later.

A native client for the tracker the team lives in. Its first auto-updater was precisely the vulnerability class it had no business being — unverified update payloads, CWE-494 — so I rebuilt the release path around Ed25519 signatures over both shipped binaries. The app now refuses any update it cannot verify, which is the only acceptable behaviour for software that replaces itself.

Every project, repository, Salesforce org and Lambda under one roof, plus the exact place each hand — human or AI — left off. Built because with this many moving systems and two people, the expensive thing isn’t writing the code, it’s re-deriving where you were three weeks ago.

A marketplace where every artifact is its own ticker. Fungible shares trade against a real central-limit order book, while specific serials and grades trade as individual objects. Royalties fund a published buyback floor, crate odds are provably fair rather than promised fair, and a geolocation hunt puts region-locked artifacts on a real map. Web first, wrapped for both mobile platforms from the same codebase.

A consumer platform built around a real-time 3D interface rather than a feed — Three.js throughout, with social, streaming and cloud-gaming surfaces sharing one spatial shell.

An interactive study app covering 127 machine-learning terms with spaced repetition and boss-battle checkpoints, built on the MIT xPRO AI/ML glossary while I was working through the programme. The fastest way to learn the vocabulary turned out to be building the thing that tests you on it.