The starting point
A small internal sales team distributing leads to partners. The workflow: open a spreadsheet, scan for a partner whose service category and city matched the lead, hand-craft a tracking URL, paste it into an email, hit send. Repeat ~5 times a day.
No audit trail. No way to know whether the partner ever called the prospect. No mechanism to retire dead partners. Lead-to-partner matching was the bottleneck. Lead-to-call follow-up was a black hole.
The constraint
Three days. Two surfaces to ship: distribution and follow-up. Target output was a closed-loop pipe where leads matched themselves, sent themselves over SMS, and resurfaced on a call queue with the JustCall recording already attached.
The only way 72 hours was realistic: skip the parts that aren't the product.
Why Zite + the JustCall MCP collapsed the schedule
Zite — fast dev AI tooling — scaffolded the working stack in a single afternoon: typed database, auth, hosting, end-to-end-typed RPC. No infra setup, no auth boilerplate, no deploy pipeline. Describe what's needed, get back a working app, iterate from there.
The JustCall MCP put every telephony surface we needed directly in the editor:
send_sms_mmsfor outbound SMSlist_calls+get_call_ai_analysisfor call synclist_contacts/create_contactfor partner recordscheck_sms_replyfor inbound reply detection
Instead of "read API docs → write fetch wrapper → debug auth → discover the response shape → handle the edge cases," the loop became "ask for what's needed, get back working code that already knows the response shape, ship." The 25-field JustCall call payload took an afternoon to wire end-to-end. Without the MCP it would've been a day of spec-doc reading.
Day 1 — the matcher
Built the distribution dashboard. A lead enters, a 3-tier match runs:
- Exact city — active partners in the same city, right service branch, haven't hit their lead cap
- Regional fallback — partners whose postal code falls within the same region (postal-code-range lookup)
- National fallback — any active branch-matched partner
Ranked by mobile-number-first (so SMS is possible) and fewest leads received. Best partner surfaces with a pre-generated tracking URL. Approve, copy, log to Sent Leads. One click.
By end of day, the spreadsheet workflow was retired for the "Copy URL" path. Volume jumped from ~5/day to ~30/day.
Day 2 — SMS over the JustCall MCP
Email was still the bottleneck. Open rate ~20%, SMS ~95%, that's the whole pitch.
Wired send_sms_mms behind a "Send SMS" button. Added Dutch mobile detection so SMS only surfaces when the partner's number can actually receive it. Added a template editor with {partnerName}, {leadCity}, {leadCategory}, {url} placeholders and a live character-count preview. Shortened the tracking URL through is.gd to keep messages under a single segment.
End of day 2: ~80 SMS/day shipped. Email path stayed as a fallback for landline-only partners.
Day 3 — closing the loop with call sync
Matching was solved. Follow-up was still a black hole — was the partner actually being called? Was the prospect picking up? What did they say?
Built the second surface against the same database. A call queue, default-filtered to "Not Spoken," with one row per claim or sent lead. Call deep-links into the JustCall dialler with the number pre-filled. After the call, Sync pulls back:
- Recording URL
- AI-generated call summary
- Customer sentiment (Positive / Negative / Neutral)
- Agent notes
- Voicemail transcription
- Full timing breakdown (ring time, hold time, conversation time)
The cleverest bit: auto-spoken on AI summary. JustCall AI only generates a summary when a real conversation took place long enough to transcribe — so the presence of an AI summary is a reliable "they actually talked" signal. If the sync returns a non-empty summary, the row flips spoken = true without a human checking a box.
A one-off backfill script ran the same logic over historical rows and auto-marked 26 records as spoken (3 claims + 23 sent leads) in a single cron run.
The numbers
| Before | After |
|---|---|
| ~5 emails/day | ~100 SMS/day |
| Hand-crafted URLs in a spreadsheet | One-click matched URL with audit trail |
| No follow-up signal | Recording + AI summary on every call |
| Partner status lived in spreadsheets | Reject / pause / skip from the UI |
| Manual "did they speak?" tracking | Auto-spoken when JustCall AI returns a summary |
20× outbound volume in 72 hours.
What the MCP unlocked that a REST client doesn't
Three things stood out:
Field discovery is free. JustCall's API has drifted across versions — AI summary lives at
call.justcall_ai.call_summaryfor newer accounts,call.ai_data.summaryfor older ones,call.call_info.ai_summaryin some tiers. The MCP surfaced the actual shape per call, so the multi-path fallback chain wrote itself instead of being chased through tickets.Auth is somebody else's problem. No
Authorization: ${key}:${secret}headers to forget, no Basic-vs-Bearer confusion, no leaked secrets in logs. The MCP holds the credential.The iteration loop is conversational. "Get me the last call to this number, with AI data, sorted desc" is four MCP calls or one prompt. 72 hours is only realistic when each "try it, see what comes back, adjust" round is seconds, not minutes.
What's next
The shape works. Distribution + follow-up is one closed-loop pipe.
Same playbook, more flows:
- First-touch acquisition SMS — replacing cold-email at the top of the funnel
- Reactivation flows — automated SMS to dormant partners with a "still want leads?" check
- Multi-step nurture — branching SMS sequences gated on JustCall reply detection
Each one is two-to-three days of work, not three weeks. That's the real win — not the 20× volume lift, the 10× compression of the build cycle.