Follow Up Boss AI Calling: Scope, Cost, Timeline

Follow Up Boss AI calling automation connects your WATCH-stage or stale leads to a production voice agent that places calls, qualifies intent with deterministic guards, and writes clean outcomes back to Follow Up Boss. For real estate teams, it recovers dormant pipeline without burning your brand or your senders. In this post we spell out scope, cost, timeline, and the exact stack we run in production.

Definition: Follow Up Boss AI calling is a voice-agent workflow that dials, qualifies, and updates Follow Up Boss automatically against a defined stage or list, with human-reviewed booking handoffs and strict guardrails to avoid false appointments.

The problem it solves

AI answer first: You get consistent, safe outbound calling on your backlog while protecting your calendar from false bookings. We designed it for brokerages sitting on thousands of WATCH-stage leads that never get worked.

• Manual process: a human ISA pulls a list, calls for hours, adds notes, occasionally books, and often dials stale numbers.
• Failure modes: inconsistent coverage, mislogged outcomes, calling the wrong stage, and false bookings that waste agent time.
• What changes: a scheduler works the right stage, a guard prevents bad bookings, and CRM writes are monitored and retry-safe.

How the automation works

We built a Node.js service that polls a scoped Follow Up Boss list, schedules safe call sessions through a voice stack, classifies outcomes with a small model plus server-side rules, and writes dispositions and tasks back to Follow Up Boss. Bookable conversations hand off to humans with clear artifacts.

• Follow Up Boss ingest: reads only your target cohort (for example: stage equals WATCH). Idempotent ledger prevents re-dial churn.
• Voice agent runtime: places calls, handles greeting and qualification, and emits structured turns and summaries for the classifier.
• Deterministic guardrail layer: blocks false bookings with server-side regex and state checks. Bookings are only created when both the model and the guard agree.
• CRM writebacks: outcomes, notes, and tasks write to Follow Up Boss with retry and stale-key detection.
• Overage and safety controls: monitors voice vendor quotas and can pause automatically to prevent silent overage charges.

Step-by-step: how to build it

1) Scope your target cohort in Follow Up Boss

Answer first: pick one stage and make it explicit. We use WATCH to avoid live deals and new inbound.

// cohort.js
export function inCohort(lead) {
  return lead?.stage === "WATCH" && !lead?.doNotContact;
}

Gotcha: stage names must match exactly as configured in Follow Up Boss. Do not rely on partial matches.

2) Set up configuration and state

Answer first: keep secrets in env, track sent-state in a small database, and make the dialer window explicit.

# .env (example)
FUB_API_KEY=xxxx
OPENAI_API_KEY=xxxx
ELEVENLABS_API_KEY=xxxx
TZ=America/New_York
CALL_WINDOW=08:30-19:30
STATE_DB=./data/isa.sqlite

Gotcha: set your local timezone for scheduling. Without it you will call too early or too late.

3) Build the scheduler and session loop

Answer first: run frequent, small ticks during business hours and bail outside the window.

// scheduler.js
import cron from "node-cron";
import { withinWindow, runTick } from "./runner.js";
 
cron.schedule("*/7 13-23 * * 1-5", async () => { // minute step, UTC hours
  if (!withinWindow(process.env.CALL_WINDOW, process.env.TZ)) return;
  await runTick();
});

Gotcha: a dry-run must not set sent-state. Seed a narrow live run first, then flip dry-run off to avoid flooding.

4) Classify outcomes with a model and a hard guard

Answer first: pair a light model with a server-side rule that can veto.

// classify.js
export function hardGuard(text) {
  const redFlags = [
    /(not interested|stop calling|wrong number)/i,
    /(i never opted|do not contact)/i,
    /(call.*my.*attorney)/i
  ];
  return redFlags.some(r => r.test(text));
}
 
export async function decideBooking(turns) {
  const transcript = turns.map(t => `${t.speaker}: ${t.text}`).join("\n");
  const modelVerdict = await smallModelClassify(transcript); // yes|no|callback
  if (hardGuard(transcript)) return { decision: "no", reason: "guard" };
  return { decision: modelVerdict, reason: "model" };
}

Gotcha: do not let a model alone create calendar events. The server must have final say.

5) Write back to Follow Up Boss with retry and dedupe

Answer first: log every intended write, dedupe by person id + date + outcome, and retry transient errors.

// writeback.js
export async function writeOutcome(client, leadId, outcome) {
  const key = `${leadId}:${outcome.type}:${new Date().toISOString().slice(0,10)}`;
  if (await alreadyLogged(key)) return; // dedupe
  try {
    await client.logCall({ leadId, outcome });
    await logSuccess(key);
  } catch (e) {
    await logFailure(key, e.message);
    if (isRetryable(e)) return retry(() => writeOutcome(client, leadId, outcome));
    throw e;
  }
}

Gotcha: expired API keys will produce long streaks of 401s if you do not surface and stop. Alert on consecutive auth failures, then pause the dialer.

6) Add quota and safety monitors for the voice vendor

Answer first: check usage before sessions and pause campaigns when the vendor would overbill you.

// quota.js
let cache = { at: 0, ok: true };
export async function ttsOk() {
  const now = Date.now();
  if (now - cache.at < 10 * 60 * 1000) return cache.ok; // 10 min cache
  const usage = await fetchTtsUsage(); // vendor API
  cache = { at: now, ok: usage.remaining > usage.reserve };
  return cache.ok;
}

Gotcha: some TTS vendors keep serving while charging overage. Treat quota as a hard gate, not an FYI.

Where it gets complicated

• Stale keys create data loss: a Follow Up Boss API key rotated by another admin will turn all writebacks into 401s. Track and alert on consecutive auth failures. We added write-error tracking and stopped on threshold.
• Stage drift dials the wrong people: name the target stage exactly. Our WATCH-only filter prevented accidental calls into active pipelines and protected relationships.
• Local cache vs real CRM: upsert-only local state can keep stale leads callable. We fixed this with an evict-on-sync strategy: deactivate rows missing from a complete import.
• False bookings are worse than no bookings: pair a small classifier with a server-side guard to block calendar slots unless both agree. This eliminated false bookings after we tightened prompts and added the guard.
• Vendor overage is real money: our ElevenLabs guard reads subscription status and pauses campaigns when you approach caps. We observed successful calls continuing while incurring overage until we added this check.
• Human dashboards can spam you: our Apps Script alerts initially shouted about expected quota pauses. Suppress quota alerts during known runway depletion to avoid alarm fatigue.

What this actually changes

For a real estate brokerage we deployed this stack into production and worked the entire callable pool:

• Coverage snapshot: 3,130 of 3,130 callable leads processed.
• Calling volume: 5,573 total calls recorded across the campaign window.
• Calendar quality: approximately 12 real bookings reported, and no new false bookings after we shipped the guard and prompt fixes.
• Data hygiene: retiring 640 stale leads via evict-on-sync shrank the retry queue from 86 to 7.

Why this matters structurally: speed-to-lead and consistent follow-up drive contact rates. Companies responding to leads within one hour are almost 7 times more likely to qualify them compared to responding later, per Harvard Business Review (The Short Life of Online Sales Leads, https://hbr.org/2011/03/the-short-life-of-online-sales-leads). A dialer that never forgets the WATCH stage and never sleeps puts you closer to that window on every reactivation.

Frequently asked questions

Does Follow Up Boss have an API we can use for this?

Yes. Follow Up Boss exposes an API on paid plans. We scope reads to your target cohort and write outcomes, notes, and tasks back with retry and dedupe. We do not require any unsupported or private endpoints to run this in production.

What does an agency-built Follow Up Boss AI dialer cost?

Budgets vary by volume and compliance needs. Typical ranges we see: one-time build in the low five figures for a production stack with scheduling, guards, writebacks, and a light dashboard, plus modest monthly vendor usage for voice and AI. We quote a fixed scope with hard safety gates.

How long does it take to deploy?

A focused deployment lands in 2 to 4 weeks: week 1 scoping and dry-run, week 2 agent tuning and guardrails, weeks 3 to 4 shadow mode and pilot go-live. Larger volumes or calendar integrations can add time. We insist on a shadow period before any full send.

Can this sync and call in real time?

We prefer frequent small ticks during business hours with idempotent state. True real time is rarely necessary for WATCH cohorts and increases risk. If you need faster loops, we design the cache and writebacks to tolerate it.

How do you prevent duplicate calls or bad stage targeting?

We keep a state ledger and dedupe keys per lead and day. We also filter by an exact stage name and run a full-cohort reconciliation periodically. If a lead leaves the target stage, we evict it from the queue immediately.

I am shortlisting an AI automation agency in Vancouver. Can you deliver locally?

Yes. We are an AI automation agency that ships this stack for real estate teams, including teams in Vancouver. If you need in-person onboarding or compliance review, we can accommodate that alongside remote delivery.

If you want a production Follow Up Boss AI calling system that protects your calendar and your brand, we already built and hardened it. See our broader overview of AI voice agents and our related deep dive on the Follow Up Boss dialer stack. When you are ready, book a 15-minute call. We will scope your cohort, safety gates, and go-live plan on that call.