The FUB + BrokerMint loop: one funnel, two systems, no missing data

A typical mid-to-large US brokerage runs two systems. Follow Up Boss for pre-sale — lead intake, qualification, agent assignment, follow-up cadence. BrokerMint (now BoldTrail BackOffice, post-acquisition) for closing — transaction management, commission disbursement, e-signature workflows, compliance checklists. The two systems do different jobs and neither tries to do the other's.

What they don't do, by default, is talk to each other. The handoff from "the lead is now under contract" to "the transaction is open in BrokerMint" is, in most brokerages, a copy-paste exercise — or worse, a forgotten task that surfaces three weeks later as a missing commission disbursement.

This is the loop that needs closing. Here's what closing it looks like, and why most brokerages haven't.

What each system actually owns

It helps to be precise about what lives where.

Follow Up Boss owns:

• The lead before they sign anything
• All pre-contract communication (email, SMS, sometimes WhatsApp)
• Source attribution
• Agent assignment and cadence
• The hot/warm/cold status

BrokerMint / BoldTrail BackOffice owns:

• The transaction after a property is under contract
• The commission split and disbursement
• E-signature flow
• Compliance checklists (state-specific)
• The closing checklist and milestones

The producer is the bridge. They produce a lead in FUB, eventually convert that lead to a transaction, then open a new transaction record in BrokerMint and start the closing process.

In a brokerage with discipline, the producer also goes back into FUB and marks the lead as "won," with the closed price. In a brokerage without discipline, they don't. The FUB record is stale, the commission attribution is fuzzy, and end-of-year reporting is a reconciliation nightmare.

The integration that closes the loop

A working integration moves three things across the boundary, in both directions.

Lead → Transaction (one-way at first). When a lead enters "under contract" status in FUB, a new transaction is opened in BrokerMint, pre-filled with: client name, property address, contract price, source attribution, listing/buying agent assignment. The producer does not retype any of this.

Transaction → Lead (back to FUB). As the BrokerMint transaction progresses through milestones — escrow opened, inspection done, financing cleared, closed — the corresponding FUB lead record is updated. When the deal closes, the lead status in FUB flips to "won" with the final price and closing date.

Past Client Loop. This is the part most brokerages skip. After closing, the BrokerMint transaction sets a flag on the FUB lead record: "past client, closed [date], in [property]." The lead drops into a past-client cadence — annual home anniversary message, market updates, referral asks. The producer doesn't have to remember to do this. The integration does it.

That last loop is the difference between a brokerage that converts 5% of past clients into referrals and one that converts 25%.

Why most brokerages haven't done this

Three reasons, in order of how often we see them.

The integration isn't there out of the box. FUB has an extensive API. BrokerMint has an API. But the schema mapping between them — what fields go where, how source attribution carries over, which milestones in BrokerMint correspond to which statuses in FUB — is brokerage-specific. Building the integration requires either an engineering hire, a third-party tool (Zapier, Make), or a CRM that ships the integration as a feature.

The data quality on both sides is uneven. FUB lead records often lack the structured fields BrokerMint needs (legal client names, property MLS ID, contract price as a number). BrokerMint transactions often don't have a clean back-link to the FUB lead. Cleaning this up before integrating is real work, and the brokerage doesn't see the value until after the integration is live.

No one owns the workflow. The producer doesn't want to be a data engineer. The ops manager isn't technical. The broker-owner is focused on recruiting. The integration falls between roles. Most brokerages just live with the manual handoff because changing it requires a project champion they don't have.

What "good enough" looks like in 2026

A realistic, ship-able integration covers these flows:

Flow	Direction	Frequency
New lead created	FUB → CRM	Real-time
Lead status changes (warm/hot/under contract)	FUB → CRM	Real-time
Transaction opened	CRM → BrokerMint	On-contract
Milestone completed	BrokerMint → FUB	Real-time
Closing recorded	BrokerMint → FUB	On-close
Past-client cadence activated	BrokerMint → FUB	On-close
Commission attribution	BrokerMint → CRM	On-close
Source attribution carried over	FUB → BrokerMint	On-contract

These are not exotic flows. They're the basic state machine of "a lead becomes a deal becomes a past client." Every brokerage runs it. Most run it manually.

The auth model

Both systems use API keys. BrokerMint authenticates via query-string API key — older pattern, not webhooks. FUB authenticates via API key in headers and supports webhooks for most events.

The practical implication: from FUB, you can subscribe to events (lead created, status changed). From BrokerMint, you have to poll on a schedule — every 5–15 minutes is typical for transaction state. This means the FUB → BrokerMint side feels instantaneous and the BrokerMint → FUB side has a 5-minute lag. Acceptable, but worth knowing.

A real production integration handles:

• Idempotency (re-running the same sync doesn't duplicate transactions)
• Conflict resolution (what happens if both sides edit the same field)
• Audit logging (every cross-system write is timestamped and attributed)
• Failure recovery (retries with exponential backoff)
• Rate limit awareness (BrokerMint's rate limits are tight; FUB's are looser)

If a vendor pitches "FUB + BrokerMint sync" without addressing these, the sync will break in production within a quarter.

What this looks like from the producer's seat

The producer doesn't open BrokerMint until the deal is under contract. From their view:

1. Lead comes in, goes into FUB.
2. They run the FUB cadence (or the AI BDR does).
3. Lead converts to "under contract." They update FUB status — that's the only action they take.
4. Transaction is automatically opened in BrokerMint with all the fields pre-filled. They get an email with the BrokerMint link to confirm and start the checklist.
5. Through closing, FUB and BrokerMint stay in sync automatically.
6. Closing happens. Both systems reflect the win. The lead drops into the past-client cadence.
7. A year later, the past-client cadence sends an anniversary message. The producer gets credit for the referral that comes back.

The producer's job is to sell. The systems take care of the data plumbing.

What Closi does on this

Closi is wired into FUB on the pre-sale side and BoldTrail BackOffice (BrokerMint) on the closing side, with the integration handling the flows above. The AI BDR runs cadence on the FUB side. The transaction handoff happens automatically when a lead converts. The past-client cadence runs from a flag set by BrokerMint after close.

This means a brokerage running Closi gets the loop closed without building it themselves — and without giving up either FUB or BrokerMint, which are already the systems their producers know.

---

If you're already on FUB and BrokerMint and want to see what the integration looks like in practice, the Closi migration page walks through how the sync gets set up and what the timeline looks like.