Chris Buys Houses - Full Operations Backend
Chris ran his lead pipeline through two separate platforms - DataSift for property data and GoHighLevel for sales outreach. Nothing talked to each other. His team was updating both by hand every time a lead moved stages, and every morning he'd sit down and manually process updates before he could start real work.
- Two-way sync between DataSift and GoHighLevel - dispositions, attempt tracking, pipeline stages, and sold status all flow in both directions automatically
- Bulk operations DataSift didn't support on its own - tier tagging across two priority levels, auto-list cleanup, bulk sold status updates, and overlap dedup between tiers
- Centralized API layer - every DataSift action runs through one helper workflow with built-in retry logic, so if a call fails it retries with a fresh token before giving up
- Token manager with shared state via Google Sheets - all 12 workflows pull from the same session token. If it expires mid-run, the token manager re-authenticates, updates the sheet, and hands the fresh token back so the workflow picks up without failing
- Slack notifier handling both error alerts and a daily activity log - record counts, what ran, what didn't, errors flagged
Cross-System Sync
When a lead's disposition changes in GoHighLevel, this picks it up via webhook, validates the payload, grabs a fresh token, searches DataSift for the matching owner by phone, updates their phone status, and logs everything to Sheets with a Slack notification. If the owner isn't found or the API errors, those get logged separately.
Tracks call and SMS attempts from GHL back into DataSift. Finds the matching property, updates attempt counts for phone and SMS separately. Results get aggregated and logged. Unmatched properties get marked and reported instead of dropped.
When an opportunity moves to sold in GHL, this catches it and bulk-marks the matching record in DataSift. Hardest workflow in the whole build - both platforms had their own definition of "sold" and getting those to agree took more time than most of the other workflows combined. Has its own token refresh logic.
The reverse direction. When a contact gets marked sold in REISift, this looks them up in GHL, finds the matching opportunity, tags the contact, and moves the opp to sold. Handles cases where the contact exists but the opportunity doesn't, or where the contact isn't in GHL at all.
Daily Batch Operations
Scheduled job. Pulls leads that qualify for Tier 1 priority (HOT FTM and 4+ criteria) and tags them in bulk through the centralized API helper. This was a manual process Chris did every morning.
Same pattern for Tier 2 leads. Pulls from two different list criteria (3+ and Lists) and tags them through the API helper. Runs right after Tier 1.
Dedup logic. If a lead qualifies for both tiers, it should only show as Tier 1. Strips the Tier 2 tag from overlaps so the team isn't seeing duplicates across priority lists.
Most complex daily workflow. Searches DataSift for "soon to be sold" records, normalizes the data, pushes sold status to GHL, then bulk-marks them in DataSift. Has its own token refresh with retry - if the search gets a 401, it force-refreshes and retries before alerting Slack. Logs success and failure counts.
Scheduled cleanup. Removes records from DataSift's auto-generated lists that shouldn't be there anymore. Runs through the same centralized API helper.
Infrastructure
The backbone. Every workflow that talks to DataSift calls this first. Reads the current token from a shared Google Sheet, checks if it's valid, and either returns it or logs into DataSift for a fresh one. The sheet acts as shared state - two workflows running at the same time both pull from the same token instead of fighting over sessions. Daily safety check plus a Slack alert if login ever fails.
Centralized API layer. Every DataSift action in the system routes through this one workflow. Grabs the token, makes the call, and on a 401 it force-refreshes and retries once before flagging. Logs successes and failures to Slack with separate paths for zero-match, real errors, and retry failures.
Dual-purpose notification hub. Real-time: any workflow sends errors here for immediate Slack alerts. Daily: runs at 8 PM CT, builds an end-of-day digest - how many records updated, what ran, what errored - posts to the logs channel. If the digest itself fails, that error gets routed to the errors channel too.
Client Onboarding Automation
A new client fills out an intake form. From there, everything happens automatically:
- Creates a project folder structure in Google Drive
- Spins up a Trello card with a pre-built checklist
- Sends a branded HTML welcome email to the client
- Logs the onboarding event to Google Sheets
- Posts a summary to the team's Slack channel
- Error handling on every external node so nothing fails silently
Webhook catches the Google Form submission and maps the raw fields into clean variables - name, email, service tier, key details. A dedup check runs against Google Sheets to make sure this isn't a re-submission. New clients get a full workspace built out: root folder in Drive with subfolders for deliverables, assets, and contracts. Then a Trello card gets created with an onboarding checklist, a service agreement doc gets added, a schedule kickoff and prep workspace get set up, and a branded welcome email goes out. Everything logs to a Sheets onboarding tracker, and the team gets a Slack ping. Duplicates get caught early and sent a notice instead of going through the full pipeline. Every external node has an error path that routes to a sticky-noted error handler so nothing fails silently.
Shopify Custom Order Intake
Built for a custom product shop (demo brand: "Timber & Thread Co."). When a Shopify order comes in with customization details buried in the order notes field:
- DeepSeek AI extracts the specs (size, material, color, engraving text, whatever the customer typed)
- Creates a structured production task in Airtable with all specs broken out
- Sends a branded HTML confirmation email to the buyer with their customization details listed back to them
Shopify order webhook fires the moment a new order comes in. The order notes field - where customers type their customization requests in plain English - gets sent to DeepSeek via OpenRouter. The AI extracts structured specs (size, material, color, engraving text, whatever they wrote) and the output gets parsed and cleaned. That structured data creates an Airtable production task with every spec broken out into its own field so the production team doesn't have to interpret anything. A confirmation email goes back to the buyer listing exactly what was captured. Final node responds OK back to Shopify.
Revision Request Tracker
Monitors a Gmail inbox for emails that look like revision requests. When one comes in:
- AI parses the email to extract what the client wants changed, which project it's for, and how urgent it is
- Logs it to Google Sheets with all fields structured
- If the AI flags it as urgent, fires a Telegram ping to the project owner immediately
- Sends an acknowledgment email back to the client so they know it was received
Gmail trigger checks the inbox every minute. A client list loads from Sheets so the system knows whose emails to care about - anything from an unknown sender gets dropped. AI reads the email through OpenRouter and determines if it's a revision request, what the client wants changed, which project it's for, and the priority level. Non-revisions get filtered out. A dedup check prevents the same email from being logged or replied to twice. The revision gets logged to Sheets with structured fields, an acknowledgment reply goes back to the client, and if the priority is urgent or high, the team gets a Telegram ping.
Inbox to CRM Pipeline
Not every email deserves CRM attention. This workflow:
- Watches Gmail for new messages
- Filters out marketing, newsletters, and noise automatically
- Runs the remaining emails through DeepSeek to extract sender, intent, urgency, and relevant details
- Creates a structured entry in Notion with all that context
- Posts a clean summary to Slack so the owner can scan it without opening email
Gmail trigger catches new emails. First gate filters out marketing, newsletters, and automated messages so only real correspondence gets through. The email body gets cleaned (HTML stripped, formatting normalized) before hitting the AI. DeepSeek via OpenRouter reads the cleaned email and extracts sender info, intent, urgency, and key details into structured fields. That structured data creates a Notion CRM entry with full context, and a Slack message goes to the owner with a clean summary so they know what came in without opening their inbox.
Lead Triage System
When a lead comes in through any web form:
- Normalizes the form data regardless of which form platform sent it
- DeepSeek scores the lead on quality (budget signals, urgency, fit)
- Logs to Google Sheets with the score and reasoning
- Fires a Slack alert with the score so the sales person knows whether to prioritize it or let it sit
Tally form trigger catches submissions. A normalize step maps the raw form fields into a standard format so it doesn't matter which form platform sent it - swap the trigger and the rest still works. DeepSeek scores the lead on quality based on budget signals, urgency, and fit, then returns a score with reasoning. That gets parsed and built into a row for Sheets (score, status, reasoning included) and a Slack alert goes to the owner so they know who to call back first.
Cold Outreach Engine
A Google Maps scraper pulls prospect data into a lead sheet, and a two-account Gmail outreach system sends personalized cold emails with automated follow-ups. The scraper is a basic free alternative to paid lead databases - enough to get moving on a scraps budget. For higher-volume needs, paid lead sources can plug straight into the same pipeline.
- Google Maps scraper runs daily, loops through search queries, deduplicates against existing leads, and appends clean rows to the pipeline sheet
- AI writes each cold email from scratch based on the prospect's actual business - no templates
- Two Gmail accounts with staggered send windows (cold: 8-10am, FU1: 10am-12pm, FU2: 12-2pm)
- Cross-account dedup so the same prospect never gets emailed twice
- Each account has its own cold, FU1, and FU2 workflow - same logic, duplicated for volume
- Five rotating templates per follow-up stage
Runs daily at 2am. Generates a batch of search queries (niche + location combos), loops through each one hitting a self-hosted Google Maps scraper on the VPS. Results get cleaned of junk emails, deduplicated against the existing lead sheet, and new leads get appended. A Telegram alert fires with the count of new leads found. The 30-second wait between queries keeps it from getting rate-limited.
Runs every 5 minutes during the 8-10am send window on weekdays. Reads the pipeline sheet, picks the next unsent lead, checks if the daily cap is hit. If there's room, AI generates a cold email from scratch based on the prospect's business data - no canned templates. The AI output gets parsed and a skip-check catches anything that doesn't look right before sending. Row gets updated with the sent status. Account B runs the same logic on odd rows.
Every 30 minutes during the 10am-12pm window. Reads the pipeline, picks leads that are due for their first follow-up (based on days since cold send). If any are due today, sends from one of five rotating templates and updates the row status to FU2 stage. If nothing is due, it stops cleanly. Account B runs an identical workflow on its own rows.
Same structure as FU1 but runs 12pm-2pm with bow-out templates. Last touch in the sequence. After this send, the row gets marked for archive. Account B mirrors this on odd rows.
Facebook Lead Scout
Passively monitors 20 Facebook groups for potential clients:
- RSS feeds watch all 20 groups on a loop
- AI classifier reads every post and decides GO, MAYBE, or SKIP based on buying signals
- Dedup sheet so no lead gets surfaced twice
- Telegram alerts on every GO with context and the direct link to the post
The parent pipeline. Runs on a schedule trigger, reads the config sheet for group list and settings, loads the seen-posts dedup sheet, and checks if the workflow is set to active. If it is, it builds the RSS feed URLs for all groups, fetches them, parses and filters the raw feed data, then sends each unseen post to the classifier as a sub-workflow. Classified posts get saved to the seen-posts sheet so they don't get processed twice.
Called by the scout for each post. Builds the LLM request with the post content and the classification prompt (10+ iterations of tuning to reduce false positives). Sends it to DeepSeek via OpenRouter, parses the response for GO/MAYBE/SKIP plus reasoning. If it's a GO, formats a Telegram alert with the post content, group name, direct link, and the AI's reasoning, then sends it. Results get merged back to the parent pipeline regardless of classification.
