The AI Automation
Blueprint Pack

Log in to Make.com and click "Create a new scenario". Name it Lead Capture - Instant Follow-Up.

Click the "+" button and search for "Webhooks". Select the module "Webhooks > Custom webhook". Click "Add" to create a new webhook. Name it Lead Form Webhook. Copy the URL that Make generates — it will look like:

https://hook.make.com/abc123xyz789...

Keep this URL — you will paste it into your form builder in Step 2.

Option A — Typeform: Go to your Typeform → Connect → Webhooks → paste the Make.com webhook URL. Enable it.

Option B — WordPress (Gravity Forms): Install the "Gravity Forms Webhooks" add-on. Go to your form → Settings → Webhooks → Add new. Paste the Make URL. Set Request Method to POST and Request Format to JSON. Map fields:

name        →  {Name (Field ID 1):1}
email       →  {Email (Field ID 2):2}
phone       →  {Phone (Field ID 3):3}
business    →  {Business Name (Field ID 4):4}
message     →  {Message (Field ID 5):5}

Option C — Raw HTML form: Point your form's action attribute to the Make webhook URL with method="POST".

After connecting, submit a test entry so Make can detect the data structure. Go back to Make and click "Re-determine data structure" on the Webhook module, then submit your test. You should see the fields populate.

Add a new module after the Webhook: search for "OpenAI" and select "OpenAI > Create a Chat Completion".

Connect your OpenAI account (you will need an API key from platform.openai.com).

Configure the module:

• Model: gpt-4o-mini (fast and cheap)
• System Message:

You are a friendly business development assistant for a professional
services company. Write a short, warm, personalized email response to
a new lead. Use their name and reference their business/message if
provided. Keep it under 150 words. Be helpful, not salesy. End with
a clear call-to-action to book a quick call. Do not include a subject
line. Write only the email body in plain text.

• User Message:

New lead details:
Name: {{1.name}}
Email: {{1.email}}
Business: {{1.business}}
Their message: {{1.message}}

Write a personalized follow-up email for this lead.

Set Max Tokens to 300 and Temperature to 0.7.

Add the next module: "Gmail > Send an Email" (or "Email > Send an Email" if using SMTP).

Connect your Gmail account via OAuth. Configure:

• To: {{1.email}}
• From: Your business email
• Subject:

Thanks for reaching out, {{1.name}}!

• Content (HTML):

<div style="font-family: Arial, sans-serif; max-width: 600px; line-height: 1.6;">
  <p>Hi {{1.name}},</p>

  <p>{{3.choices[].message.content}}</p>

  <p><a href="https://calendly.com/YOUR-LINK/30min"
       style="display:inline-block; background:#338dff; color:#fff;
              padding:12px 28px; border-radius:6px; text-decoration:none;
              font-weight:bold;">
    Book a Free 15-Min Call
  </a></p>

  <p style="color:#666; font-size:13px;">
    If the button doesn't work, copy this link:
    https://calendly.com/YOUR-LINK/30min
  </p>

  <p>Looking forward to chatting,<br>
  [Your Name]<br>
  [Your Company]<br>
  [Your Phone]</p>
</div>

Replace YOUR-LINK with your actual Calendly (or Cal.com) scheduling link.

Add the next module: "HubSpot CRM > Create a Contact".

Connect your HubSpot account. Map the fields:

Email          →  {{1.email}}
First Name     →  {{1.name}}
Phone Number   →  {{1.phone}}
Company        →  {{1.business}}
Lead Source     →  "Website Form"
Lead Status     →  "New"
Notes           →  "Auto-captured: {{1.message}}"

If using Airtable instead: Use the "Airtable > Create a Record" module. Create a table called "Leads" with columns: Name, Email, Phone, Business, Message, Date Captured, Status. Map the same fields.

Enable "Map" toggle and add error handling: right-click the module → Add error handler → "Ignore" (in case the contact already exists).

Add: "Google Sheets > Add a Row".

Create a Google Sheet called Lead Tracker with columns: Date, Name, Email, Phone, Business, Message, Email Sent (Y/N), CRM Added (Y/N).

Map:

Date       →  {{formatDate(now; "YYYY-MM-DD HH:mm:ss")}}
Name       →  {{1.name}}
Email      →  {{1.email}}
Phone      →  {{1.phone}}
Business   →  {{1.business}}
Message    →  {{1.message}}
Email Sent →  "Yes"
CRM Added  →  "Yes"

Create a second Make.com scenario named Lead Nurture Sequence. Set the trigger to "Schedule > Every day at 9:00 AM".

Add "Google Sheets > Search Rows" — filter for leads where the "Date" column is exactly 2 days ago and "Email Sent Count" is less than 2.

For each matching row, send Follow-Up Email #2:

Subject: Quick question, {{name}}

Hi {{name}},

I wanted to follow up on your inquiry from a couple of days ago.
I know things get busy, so I just wanted to make sure you saw
my last message.

If you're still interested in [service], I'd love to hop on a
quick 15-minute call to see if we're a good fit.

Here's my calendar link: [Calendly URL]

No pressure at all — just want to make sure I'm not leaving
you hanging!

Best,
[Your Name]

Add a second iterator for leads 5 days old with fewer than 3 emails sent. Send Follow-Up #3:

Subject: Last check-in from [Company Name]

Hi {{name}},

This is my last follow-up — I don't want to be a bother!

If now isn't the right time, totally understood. But if you'd
like to explore how we can help {{business}} with [service],
my calendar is always open:

[Calendly URL]

Wishing you all the best either way.

[Your Name]

After each email, update the Google Sheet row: increment the "Email Sent Count" column and set "Last Follow-Up Date".

Turn on both scenarios. Submit a test form entry using a personal email address. Verify:

• Email arrives within 60 seconds
• Email is personalized (references your name/business)
• CRM contact was created with correct fields
• Google Sheet row was added
• Calendly link works in the email

Test the nurture sequence by manually changing a test row's date to 2 days ago, then running the second scenario manually.

In Make.com, create a new scenario: Appointment Reminders - 24hr SMS.

Add trigger: "Google Calendar > Watch Events". Connect your Google account and select your appointment calendar. Set "Watch" to Updated and newly created events. Set the schedule to run every 15 minutes.

Add a "Filter" after the trigger with this condition:

Condition: Event Start Date/Time
Operator:  "is after"
Value:     {{addHours(now; 23)}}

AND

Condition: Event Start Date/Time
Operator:  "is before"
Value:     {{addHours(now; 25)}}

This ensures we only catch events happening 23-25 hours from now (a 2-hour window, checked every 15 min, so nothing gets missed).

Sign up at twilio.com. Get a phone number (~$1/mo). Note your Account SID and Auth Token from the dashboard.

In Make.com, add module: "Twilio > Send an SMS". Connect using your Account SID and Auth Token.

Configure:

From:  Your Twilio number (+1XXXXXXXXXX)
To:    {{parsePhoneFromDescription(1.description)}}
Body:

Hi {{1.summary.split(" - ")[0]}}! This is a friendly
reminder from [Your Business] about your appointment
tomorrow, {{formatDate(1.start.dateTime; "dddd, MMMM D")}}
at {{formatDate(1.start.dateTime; "h:mm A")}}.

Location: {{1.location}}

Need to reschedule? Reply RESCHEDULE or call us at
(XXX) XXX-XXXX.

See you soon!

Extracting the phone number: Store the client's phone in the Google Calendar event description field in the format Phone: +15551234567. Use a Text Parser > Match Pattern module with regex Phone:\s*(\+?\d[\d\-\s]{9,}) to extract it.

Alternatively, if you use Calendly, the phone is captured as a form field. Use the "Calendly > Watch Events" trigger instead, which includes attendee phone directly.

Create a separate scenario: Appointment Reminders - 1hr Email. This keeps the logic clean and lets each run on its own schedule.

Trigger: "Google Calendar > Watch Events" (same calendar, runs every 15 min).

Filter: Event starts between 45 minutes and 75 minutes from now.

Add "Gmail > Send an Email":

To:      {{attendee email from calendar event}}
Subject: Your appointment is in 1 hour — here's what you need to know

Body:

Hi {{name}},

Just a quick heads up — your appointment is coming up soon!

DETAILS:
  Date: {{formatDate(1.start.dateTime; "dddd, MMMM D, YYYY")}}
  Time: {{formatDate(1.start.dateTime; "h:mm A")}}
  Location: {{1.location}}

GETTING HERE:
  Google Maps link: https://maps.google.com/?q={{urlEncode(1.location)}}

WHAT TO BRING:
  - [Customize per your business, e.g., "Photo ID",
     "Completed intake form", "Insurance card"]

If you need to reschedule, please call us at (XXX) XXX-XXXX
as soon as possible.

See you shortly!
[Your Business Name]

Create a Google Sheet called Appointment Tracker with columns:

A: Event ID
B: Client Name
C: Client Email
D: Client Phone
E: Appointment Date/Time
F: 24hr SMS Sent (checkbox)
G: 1hr Email Sent (checkbox)
H: Status (Attended / No-Show / Rescheduled)
I: Rebooking Sent

In both reminder scenarios, after sending the SMS/email, add "Google Sheets > Add a Row" (for the 24hr scenario) or "Google Sheets > Update a Row" (for the 1hr scenario, searching by Event ID) to log that the reminder was sent.

Create scenario: No-Show Detection & Rebooking. Schedule to run every hour.

Trigger: "Google Sheets > Search Rows" in your Appointment Tracker. Filter for:

Column E (Appointment Date/Time): is before {{addMinutes(now; -30)}}
Column H (Status): is empty

This finds appointments that ended 30+ minutes ago with no status recorded (meaning the staff hasn't marked them as attended).

Add a "Router" with two paths:

Path 1 — Send Rebooking SMS:

Hi {{name}}, we missed you at your appointment today!
No worries — life happens. Would you like to rebook?

Book a new time here: [Calendly/Booking Link]

Or reply to this text and we'll get you sorted.

— [Your Business]

Path 2 — Send Rebooking Email:

Subject: We missed you today — let's reschedule!

Hi {{name}},

It looks like we weren't able to connect for your
appointment today at {{time}}. No worries at all —
we'd love to get you rescheduled.

Click below to grab a new time that works for you:

[BOOK NEW APPOINTMENT BUTTON → Calendly link]

If something came up or you have any questions,
just reply to this email and we'll help you out.

Looking forward to seeing you soon,
[Your Business Name]

After both sends, update the Google Sheet row: set column H to No-Show and column I to Yes.

After each appointment, someone on your team needs to mark the Status column as "Attended" in the Google Sheet. This prevents the no-show sequence from triggering for people who actually showed up.

To make this easier: Create a Google Form with just two fields — Client Name (dropdown from your sheet) and Status (Attended/No-Show). Share this as a bookmark on staff phones. Takes 5 seconds after each appointment.

Alternatively, if you use a POS system or practice management software that tracks check-ins, connect that instead (e.g., Acuity Scheduling marks "completed" automatically).

Go to Google Business Profile → Home → "Get more reviews" → copy the review link. It looks like:

https://g.page/r/YOUR-PLACE-ID/review

Or construct it manually: go to Google Maps, find your business, click "Write a review," and copy that URL. Shorten it using bit.ly for SMS (character limits matter).

For Yelp: https://www.yelp.com/writeareview/biz/YOUR-BIZ-ID

For Facebook: https://www.facebook.com/YOUR-PAGE/reviews

Create a Google Sheet called Completed Services:

A: Completion Date
B: Client Name
C: Client Email
D: Client Phone
E: Service Performed
F: Technician/Staff Name
G: Review Request Sent (email)
H: Review Request Sent (SMS)
I: Review Received (Y/N)
J: Review Rating
K: Notes

Your team adds a row after each completed job/appointment. This is the trigger for the automation.

Tip: Create a simple Google Form that staff can fill from their phone: Client Name, Email, Phone, Service. The form auto-populates the sheet.

In Make.com, create scenario: Review Request - Email.

Trigger: "Google Sheets > Watch New Rows" in your Completed Services sheet. Set to check every 15 minutes.

Add module: "Sleep" — set to 7200 seconds (2 hours). This delay ensures the client has had time to experience the results of your service.

Add module: "Gmail > Send an Email":

To:      {{2.Client Email}}
Subject: How did we do, {{2.Client Name}}?

<div style="font-family: Arial, sans-serif; max-width: 600px;
            margin: 0 auto; padding: 20px;">

  <h2 style="color: #333;">Thanks for choosing [Your Business]!</h2>

  <p>Hi {{2.Client Name}},</p>

  <p>We hope you're happy with your {{2.Service Performed}} today!
     {{2.Technician/Staff Name}} mentioned everything went great.</p>

  <p>If you have 30 seconds, we'd really appreciate a quick
     Google review. It helps other people in the community
     find us, and it means the world to our small team.</p>

  <p style="text-align: center; margin: 30px 0;">
    <a href="[YOUR GOOGLE REVIEW LINK]"
       style="display:inline-block; background:#338dff;
              color:#fff; padding:14px 36px; border-radius:8px;
              text-decoration:none; font-weight:bold;
              font-size:16px;">
      Leave a Quick Review &rarr;
    </a>
  </p>

  <p style="color: #666; font-size: 13px;">
    It only takes 30 seconds and you'd be helping us out
    tremendously. Thank you!
  </p>

  <p>Warm regards,<br>
  [Your Name]<br>
  [Your Business]</p>

</div>

Add "Google Sheets > Update a Row": search by row number, set column G to Yes and note the send timestamp.

Create a second scenario: Review Request - SMS Follow-Up. Schedule it to run once daily at 10:00 AM (polite texting hours).

Trigger: "Google Sheets > Search Rows" with filters:

Column A (Completion Date): is before {{addDays(now; -2)}}
Column G (Email Sent):      equals "Yes"
Column H (SMS Sent):        is empty
Column I (Review Received): is empty

This finds clients who were emailed 2+ days ago but haven't left a review.

Add "Twilio > Send an SMS":

Hi {{name}}! This is [Your Name] from [Business].
We'd love to hear how your {{service}} went!

If you have 30 seconds, a Google review would
mean the world to us: [SHORT REVIEW LINK]

Thank you!

Update the row: set column H to Yes.

To close the loop, periodically check for new reviews. Create scenario: Review Monitor running daily.

Use the "HTTP > Make a Request" module to call the Google Places API:

GET https://maps.googleapis.com/maps/api/place/details/json
    ?place_id=YOUR_PLACE_ID
    &fields=reviews
    &key=YOUR_GOOGLE_API_KEY

Parse the response with a JSON module. Compare new reviews against your sheet to match names. Update column I to Yes and column J with the rating.

This tells you your review request conversion rate and which clients responded.

Option A — Stripe (if client pays to start): In Make.com, add trigger "Stripe > Watch Events". Set Event Type to checkout.session.completed. This fires when a client completes a Stripe Checkout payment.

Option B — HubSpot (if using CRM deals): Add trigger "HubSpot CRM > Watch Deals". Set the filter to Deal Stage = Closed Won. Pull the associated contact's name, email, phone, and company from the deal.

Option C — Manual trigger via Google Sheets: Add a row to an "Onboarding Queue" sheet. Use "Google Sheets > Watch New Rows" as trigger. Columns: Client Name, Email, Phone, Company, Package/Service, Start Date.

Add "Gmail > Send an Email":

To:      {{client_email}}
Subject: Welcome to [Your Company]! Let's get started.

<div style="font-family: Arial, sans-serif; max-width: 600px;
            margin: 0 auto; padding: 20px;">

  <h1 style="color: #338dff;">Welcome aboard, {{client_name}}!</h1>

  <p>We're thrilled to be working with you. Here's what
     happens next:</p>

  <h3>Step 1: Complete Your Intake Form (5 minutes)</h3>
  <p>This helps us understand your business, goals, and
     preferences so we can hit the ground running.</p>
  <p><a href="[TYPEFORM_LINK]?name={{urlEncode(client_name)}}&email={{urlEncode(client_email)}}"
       style="display:inline-block; background:#338dff;
              color:#fff; padding:12px 28px; border-radius:6px;
              text-decoration:none; font-weight:bold;">
    Complete Intake Form &rarr;
  </a></p>

  <h3>Step 2: Book Your Kickoff Call</h3>
  <p>Let's align on strategy and timeline. Pick a time
     that works for you:</p>
  <p><a href="[CALENDLY_LINK]?name={{urlEncode(client_name)}}&email={{urlEncode(client_email)}}"
       style="display:inline-block; background:#00d4aa;
              color:#fff; padding:12px 28px; border-radius:6px;
              text-decoration:none; font-weight:bold;">
    Book Kickoff Call &rarr;
  </a></p>

  <h3>What to Expect</h3>
  <ul>
    <li>Within 24 hours: We'll review your intake form</li>
    <li>Kickoff call: We'll align on goals and timeline</li>
    <li>Within 1 week: First deliverables/updates</li>
  </ul>

  <p>Questions? Reply to this email anytime.</p>

  <p>Excited to get started!<br>
  [Your Name]<br>
  [Your Company]</p>

</div>

The ?name=&email= URL parameters pre-fill the Typeform and Calendly fields so the client doesn't have to re-enter info.

Add module: "Google Drive > Create a Folder".

Parent Folder:  "Clients" (create this root folder first)
Folder Name:    {{client_company}} - {{formatDate(now; "YYYY-MM")}}

Then add three more "Create a Folder" modules to create subfolders inside the client folder:

Subfolder 1: "01 - Contracts & Invoices"
Subfolder 2: "02 - Assets & Deliverables"
Subfolder 3: "03 - Reports & Analytics"

Optional: Use "Google Drive > Copy a File" to copy a template SOW (Statement of Work) document into the Contracts subfolder, pre-filled with the client's name.

Add module: "Slack > Create a Message".

Channel:  #new-clients
Message:

:tada: *New Client Signed!*

*Client:* {{client_name}} ({{client_company}})
*Package:* {{package_name}}
*Start Date:* {{formatDate(now; "MMMM D, YYYY")}}
*Email:* {{client_email}}
*Phone:* {{client_phone}}

*Client Folder:* {{google_drive_folder_link}}

Welcome email sent. Intake form and kickoff call links delivered.
Waiting on client to complete onboarding steps.

Create a second scenario: Client Onboarding - Intake Processing.

Trigger: "Typeform > Watch Responses" connected to your intake form.

Your Typeform intake form should collect:

• Business name, website URL, industry
• Current pain points (multi-select)
• Goals for working with you (open text)
• Preferred communication method
• Brand assets (logo upload, brand colors)
• Login credentials / access (if applicable)
• Timeline expectations

After the form is submitted, add module: "Asana > Create a Project" (or ClickUp/Trello equivalent):

Workspace:   Your workspace
Team:        Your team
Name:        {{client_company}} - {{package_name}}
Template:    "Client Onboarding Template"
             (create this template in Asana first with
              your standard task list)
Due Date:    {{addDays(now; 30)}}

The template should include pre-built tasks like:

[ ] Review intake form responses
[ ] Set up client accounts/access
[ ] Create initial strategy document
[ ] Schedule kickoff call
[ ] Deliver first milestone
[ ] Week 1 check-in
[ ] Week 2 progress report
[ ] Month 1 review

After the project is created, add "Gmail > Send an Email":

Subject: You're all set, {{client_name}}! Here's your project dashboard.

Hi {{client_name}},

Thank you for completing the intake form! We've reviewed
your information and everything looks great.

Here's what we've set up for you:

YOUR PROJECT DASHBOARD:
{{asana_project_link}}

YOUR FILE FOLDER:
{{google_drive_folder_link}}

NEXT STEPS:
1. We'll review your intake responses in detail
2. Your kickoff call is [booked/pending booking]
3. You'll receive your first update within [X days]

If you haven't booked your kickoff call yet, grab a
time here: [CALENDLY LINK]

We're excited to get to work!

[Your Name]

Create a third scenario: Onboarding Nudge. Run daily at 10 AM.

Check your Google Sheet for clients where the welcome email was sent 48+ hours ago but the intake form column is still empty. Send a gentle reminder:

Subject: Quick reminder: Your intake form is waiting!

Hi {{name}},

Just a friendly nudge — we're ready to get started on
your project, but we need your completed intake form first.

It only takes about 5 minutes:
[INTAKE FORM LINK]

Once that's in, we'll have everything we need to kick
things off!

[Your Name]

Create a Google Sheet called Invoice Tracker:

A: Invoice Number
B: Client Name
C: Client Email
D: Amount
E: Invoice Date
F: Due Date
G: Status (Unpaid / Paid / Overdue)
H: Reminder 1 Sent (date)
I: Reminder 2 Sent (date)
J: Final Notice Sent (date)
K: Flagged for Manual Follow-Up
L: Payment Date
M: Notes

Create scenario: Invoice Logger.

If using QuickBooks: Trigger: "QuickBooks Online > Watch Invoices" (set to new invoices). Map Invoice Number, Customer Name, Customer Email, Total Amount, Due Date to your Google Sheet.

If using Stripe: Trigger: "Stripe > Watch Events" with event type invoice.sent. Map: invoice.number, customer_email, amount_due / 100 (Stripe stores in cents), due_date.

If manual invoicing: Simply add the row to Google Sheets yourself when you send an invoice. The follow-up automation works regardless of how the row gets there.

Set column G to Unpaid for all new entries.

Create scenario: Invoice Follow-Up Engine. Schedule: Every day at 9:00 AM.

Module 1: "Google Sheets > Search Rows" — Filter: Column G equals Unpaid.

Module 2: "Router" with three paths based on how overdue the invoice is.

Path 1 — 3 Days Overdue (Friendly Reminder):

Filter: Due Date is 3+ days ago AND column H (Reminder 1) is empty.

Subject: Friendly reminder: Invoice #{{invoice_number}} is due

Hi {{client_name}},

Hope you're doing well! Just a quick reminder that
invoice #{{invoice_number}} for ${{amount}} was due on
{{due_date}}.

If you've already sent payment, please disregard this
message — it may have crossed paths!

If not, you can view and pay your invoice here:
[INVOICE LINK or PAYMENT LINK]

Let me know if you have any questions.

Best,
[Your Name]
[Your Company]

After sending, update column H with today's date.

Path 2 — 7 Days Overdue (Firm Reminder):

Filter: Due Date is 7+ days ago AND column H is NOT empty AND column I is empty.

Subject: Payment overdue: Invoice #{{invoice_number}} — ${{amount}}

Hi {{client_name}},

I wanted to follow up regarding invoice #{{invoice_number}}
for ${{amount}}, which was due on {{due_date}} — now
{{days_overdue}} days ago.

I understand things can slip through the cracks, but I'd
appreciate if you could take a moment to process this
payment at your earliest convenience.

Pay now: [INVOICE/PAYMENT LINK]

If there's an issue with the invoice or you need to
discuss payment arrangements, please let me know and
we can work something out.

Thank you,
[Your Name]

Path 3 — 14 Days Overdue (Final Notice):

Filter: Due Date is 14+ days ago AND column I is NOT empty AND column J is empty.

Subject: FINAL NOTICE: Invoice #{{invoice_number}} — ${{amount}} overdue

Hi {{client_name}},

This is a final reminder regarding invoice
#{{invoice_number}} for ${{amount}}, originally due on
{{due_date}}.

This invoice is now {{days_overdue}} days past due.
Please process payment within the next 48 hours to
avoid any disruption to our services.

Pay now: [INVOICE/PAYMENT LINK]

If there are circumstances preventing payment, please
reach out to me directly so we can discuss options.

Regards,
[Your Name]
[Your Company]

After sending the final notice, also add a "Slack > Create a Message" module:

Channel: #accounts-receivable (or #general)

:rotating_light: *Invoice Requires Manual Follow-Up*

*Client:* {{client_name}}
*Invoice:* #{{invoice_number}}
*Amount:* ${{amount}}
*Days Overdue:* {{days_overdue}}
*Reminders Sent:* 3 (friendly, firm, final)

All automated reminders have been sent. This needs
a personal phone call or meeting to resolve.

Update column K to Yes.

Create scenario: Payment Detector. Schedule: every 30 minutes.

If using Stripe: Trigger: "Stripe > Watch Events" with event type invoice.paid. When payment is detected, search your Google Sheet for that invoice number and update: Column G to Paid, Column L to today's date.

If using QuickBooks: Use "QuickBooks Online > Watch Payments" trigger. Match the payment to the invoice in your sheet.

This stops the reminder sequence automatically — the daily check only processes rows where Status = "Unpaid".

In the Payment Detector scenario, after marking the invoice as Paid, add a thank-you email:

Subject: Payment received — thank you, {{client_name}}!

Hi {{client_name}},

Just confirming we've received your payment of ${{amount}}
for invoice #{{invoice_number}}. Thank you!

Your receipt is attached / available here: [LINK]

As always, if you need anything, don't hesitate to reach out.

Best,
[Your Name]

Create an Airtable base called Content Library with a table called Posts:

Fields:
- Post ID (Auto Number)
- Original Text (Long Text)
- Platform (Single Select: LinkedIn, Twitter/X, Instagram, Facebook)
- Post Date (Date)
- Likes (Number)
- Comments (Number)
- Shares (Number)
- Engagement Rate (Formula: (Likes + Comments*2 + Shares*3) / 1)
- Topic Tags (Multiple Select: tips, case-study, motivational, educational, promotional)
- Evergreen (Checkbox: is this content timeless?)
- Times Recycled (Number, default 0)
- Last Recycled Date (Date)
- Status (Single Select: Active, Recycled, Retired)

Start populating this with your existing content. You can do this manually or set up a separate automation that logs new posts automatically (see Variation below).

In Make.com, create scenario: Content Recycler - Monthly.

Trigger: "Schedule" — set to run on the 1st of every month at 9:00 AM.

Module 2: "Airtable > Search Records" in your Posts table.

Filter formula:
AND(
  {Evergreen} = 1,
  {Post Date} < DATEADD(TODAY(), -60, 'days'),
  OR({Times Recycled} = 0, {Last Recycled Date} < DATEADD(TODAY(), -90, 'days')),
  {Status} != 'Retired'
)
Sort: Engagement Rate (descending)
Max Records: 10

This pulls your top 10 evergreen posts that haven't been recycled in the last 90 days.

Add an "Iterator" module to loop through the 10 posts.

Inside the loop, add "OpenAI > Create a Chat Completion":

Model: gpt-4o-mini
Temperature: 0.8

System Prompt:
You are a social media content strategist. You take
high-performing posts and rewrite them with a completely
fresh angle while keeping the core message. You create
3 versions:

1. LINKEDIN version (professional tone, 150-200 words,
   use line breaks for readability, end with a question
   to drive comments)
2. TWITTER/X version (punchy, under 280 characters,
   use a hook in the first line)
3. INSTAGRAM CAPTION version (conversational, use emojis
   sparingly, include a CTA, 100-150 words, suggest
   5 relevant hashtags)

Format your response as JSON:
{
  "linkedin": "...",
  "twitter": "...",
  "instagram": "..."
}

User Prompt:
Original post that performed well:
"""
{{iterator.Original Text}}
"""

Original platform: {{iterator.Platform}}
Topic: {{iterator.Topic Tags}}

Rewrite this with a fresh angle. Keep the core insight
but use a different hook, new examples, or a different
storytelling approach. Do NOT copy the original — make
it feel like a brand new post.

Add a "JSON > Parse JSON" module to extract the three versions from the response.

After parsing the JSON, add a "Router" with three paths — one for each platform.

Path 1 — LinkedIn: Add "Buffer > Create a Post". Select your LinkedIn profile. Set text to {{json.linkedin}}. Set scheduled time using a formula that spreads posts evenly across the month:

Scheduled Time: {{addDays(now; (iterator.bundleOrder * 3))}}
(This posts every 3 days)

Path 2 — Twitter/X: Same module, select Twitter profile, use {{json.twitter}}.

Path 3 — Instagram: Same module, select Instagram profile, use {{json.instagram}}.

Alternative to Buffer: Use the "HTTP > Make a Request" module with the LinkedIn/Twitter APIs directly if you prefer not to use a scheduling tool.

After scheduling, add "Airtable > Update a Record":

Record ID: {{iterator.id}}
Fields to update:
  Times Recycled:    {{iterator.Times Recycled + 1}}
  Last Recycled Date: {{now}}
  Status:            "Recycled"

Also create a new record in a second table called Recycled Posts that logs the original post ID, all three rewritten versions, and the scheduled dates. This gives you a complete audit trail.

Create a second scenario: Content Performance Tracker. Run on the 28th of each month.

Use the Buffer API or platform APIs to pull engagement metrics for all posts published that month. Compare recycled post performance against original performance in a Google Sheet summary.

Key metrics to track: engagement rate, impressions, link clicks, follower growth attribution.

Create scenario: Weekly Business Report.

Trigger: "Schedule" → Run once per week, Monday at 7:30 AM (your timezone). We trigger at 7:30 to give the data modules time to run before the email sends at ~8:00.

Add the following modules in parallel (use a Router or sequential, both work):

CRM Data (HubSpot)

Module: "HubSpot CRM > Search Contacts"

Filter: createdate >= {{formatDate(addDays(now; -7); "YYYY-MM-DD")}}
This returns all contacts created in the last 7 days.
Use an Aggregator module to count the results: {{length(array)}}

Also pull deals: "HubSpot CRM > Search Deals" with filter on closedate in the last 7 days and dealstage = closedwon. Sum the amount field.

Calendar Data

Module: "Google Calendar > List Events"

Calendar: Your main calendar
Time Min: {{formatDate(addDays(now; -7); "YYYY-MM-DD")}}T00:00:00Z
Time Max: {{formatDate(now; "YYYY-MM-DD")}}T23:59:59Z

Use an Aggregator to count total events. Optionally categorize: client meetings, internal meetings, sales calls.

Revenue Data (Stripe)

Module: "Stripe > List Balance Transactions"

Created: after {{formatDate(addDays(now; -7); "X")}}
Type: charge
Use an Aggregator: sum all amounts (divide by 100 for dollars)

Email Activity

Module: "Gmail > Search Emails"

Query: in:sent after:{{formatDate(addDays(now; -7); "YYYY/MM/DD")}}
Use an Aggregator: count results = emails sent this week

Also count received: in:inbox after:{{date}}

Task Data (Asana/ClickUp)

Module: "Asana > Search Tasks"

Filter: completed_since={{formatDate(addDays(now; -7); "YYYY-MM-DD")}}
Count completed tasks and list any overdue tasks.

Add "Tools > Set Multiple Variables" to consolidate all data into one summary string, then feed it to OpenAI.

Module: "OpenAI > Create a Chat Completion":

Model: gpt-4o-mini
Temperature: 0.6

System Prompt:
You are a business analyst assistant. You receive weekly
business data and provide concise, actionable insights.
Format your response in 3 sections:

1. KEY HIGHLIGHTS (2-3 bullet points of what went well)
2. AREAS TO WATCH (2-3 bullet points of potential concerns)
3. RECOMMENDED ACTIONS (2-3 specific things to do this week)

Be specific and data-driven. Reference the actual numbers.
Keep the total response under 200 words.

User Prompt:
Here is this week's business data ({{formatDate(addDays(now;-7);"MMM D")}} - {{formatDate(now;"MMM D, YYYY")}}):

NEW LEADS: {{leads_count}} (last week: {{prev_leads_count}})
DEALS CLOSED: {{deals_count}} worth ${{deals_value}}
APPOINTMENTS: {{calendar_count}}
REVENUE COLLECTED: ${{revenue}}
EMAILS SENT: {{emails_sent}}
EMAILS RECEIVED: {{emails_received}}
TASKS COMPLETED: {{tasks_completed}}
OVERDUE TASKS: {{overdue_tasks}}

Provide your analysis.

Add "Gmail > Send an Email" with HTML body. Here is the complete email template:

Subject: Weekly Report: {{formatDate(addDays(now;-7);"MMM D")}} - {{formatDate(now;"MMM D, YYYY")}}

<div style="font-family:Arial,sans-serif; max-width:650px;
            margin:0 auto; background:#f8f9fa; padding:30px;">

  <div style="background:#338dff; color:#fff; padding:24px;
              border-radius:12px 12px 0 0; text-align:center;">
    <h1 style="margin:0; font-size:22px;">WEEKLY BUSINESS REPORT</h1>
    <p style="color:#9ca3af; margin:8px 0 0;">
      {{formatDate(addDays(now;-7);"MMM D")}} &mdash;
      {{formatDate(now;"MMM D, YYYY")}}
    </p>
  </div>

  <div style="background:#fff; padding:24px; border:1px solid #e5e7eb;">

    <h2 style="color:#338dff; font-size:16px; margin-top:0;">
      KEY METRICS
    </h2>

    <table style="width:100%; border-collapse:collapse;">
      <tr>
        <td style="padding:12px; border-bottom:1px solid #eee;">
          <strong>New Leads</strong>
        </td>
        <td style="padding:12px; text-align:right; border-bottom:1px solid #eee;
                    font-size:24px; font-weight:bold; color:#338dff;">
          {{leads_count}}
        </td>
      </tr>
      <!-- Repeat for each metric: Deals Closed, Revenue,
           Appointments, Emails Sent, Tasks Completed -->
    </table>

    <h2 style="color:#00d4aa; font-size:16px; margin-top:24px;">
      AI INSIGHTS
    </h2>
    <div style="background:#f0fdf4; padding:16px; border-radius:8px;
                border-left:4px solid #00d4aa;">
      {{openai_insights}}
    </div>

  </div>

  <div style="text-align:center; padding:16px; color:#9ca3af;
              font-size:12px;">
    Generated by Jedai Flow Automation
  </div>

</div>

Add "Google Sheets > Add a Row" to a Weekly Reports Archive sheet. Log: Week Ending Date, Leads, Deals, Revenue, Appointments, Emails, Tasks. Over time, this creates a trend dataset you can chart.

Option A — Email-based: Create a dedicated support email (support@yourdomain.com). In Make.com, trigger: "Gmail > Watch Emails" with label filter for "Inbox" on this account. This catches every incoming email.

Option B — Form-based: Create a support form (Typeform, Tally, or your website). Use a Webhook trigger to catch submissions.

For email, the key data is: from_email, from_name, subject, body_text, date.

Add "OpenAI > Create a Chat Completion":

Model: gpt-4o-mini
Temperature: 0.3 (low for consistent categorization)

System Prompt:
You are a customer support triage AI. Analyze the
incoming support request and respond with a JSON object:

{
  "urgency": "critical|high|medium|low",
  "category": "billing|technical|general|feature_request|complaint",
  "summary": "One-line summary of the issue",
  "suggested_response": "A polite, helpful response
    the support team can use as a starting point",
  "estimated_resolution": "Estimated time to resolve
    (e.g., '1 hour', '24 hours', '2-3 business days')",
  "route_to": "Name of team/person based on category"
}

Urgency guidelines:
- CRITICAL: Service is down, data loss, security issue,
  payment failed for active subscription
- HIGH: Feature broken but workaround exists, urgent
  deadline mentioned, angry/frustrated tone
- MEDIUM: General question, how-to request, minor bug
- LOW: Feature request, general feedback, FYI messages

User Prompt:
From: {{from_name}} ({{from_email}})
Subject: {{subject}}
Message:
{{body_text}}

Add "JSON > Parse JSON" to extract the structured response.

Add "Airtable > Create a Record" in a Support Tickets table:

Fields:
  Ticket ID:       Auto-generated (TICK-{{formatDate(now;"YYMMDDHHmmss")}})
  Customer Name:   {{from_name}}
  Customer Email:  {{from_email}}
  Subject:         {{subject}}
  Message:         {{body_text}}
  Urgency:         {{json.urgency}}
  Category:        {{json.category}}
  AI Summary:      {{json.summary}}
  Suggested Response: {{json.suggested_response}}
  Status:          "Open"
  Assigned To:     {{json.route_to}}
  Created At:      {{now}}
  Resolved At:     (empty)
  Response Time:   (empty - calculated when resolved)

Add "Gmail > Send an Email":

To:      {{from_email}}
Subject: Re: {{subject}} [Ticket #{{ticket_id}}]

Hi {{from_name}},

Thank you for reaching out! We've received your message
and a member of our team is already looking into it.

YOUR TICKET: #{{ticket_id}}
ESTIMATED RESPONSE TIME: {{json.estimated_resolution}}

Here's what to expect:
- A team member will respond within {{json.estimated_resolution}}
- You'll receive updates via email
- If this is urgent, call us at (XXX) XXX-XXXX

In the meantime, you might find our FAQ helpful:
[FAQ LINK]

We appreciate your patience!

Best,
[Your Company] Support Team

Add a "Router" with paths based on {{json.category}}:

Path: Billing (filter: category = "billing") → "Slack > Create a Message" in #support-billing

Path: Technical (filter: category = "technical") → Slack in #support-technical

Path: All others (fallback) → Slack in #support-general

Slack message format:

:ticket: *New Support Ticket*  [{{json.urgency | uppercase}}]

*Ticket:* #{{ticket_id}}
*From:* {{from_name}} ({{from_email}})
*Subject:* {{subject}}
*Category:* {{json.category}}

*AI Summary:* {{json.summary}}

*Customer's Message:*
> {{body_text | truncate(500)}}

*Suggested Response:*
{{json.suggested_response}}

:point_right: React with :eyes: when you're handling this.
:point_right: React with :white_check_mark: when resolved.

For CRITICAL urgency tickets, also add a Slack DM to the team lead/manager.

Create a separate scenario: Support Ticket Escalation. Run every 30 minutes.

Module: "Airtable > Search Records" — filter:

Status = "Open"
Created At < {{addHours(now; -2)}}
Urgency IN ["critical", "high"]

For each unresolved ticket, send a Slack DM to the manager:

:rotating_light: *ESCALATION: Ticket #{{ticket_id}} unresolved for 2+ hours*

Customer: {{customer_name}}
Urgency: {{urgency}}
Summary: {{ai_summary}}

This ticket needs immediate attention.
Original channel: #support-{{category}}

Also update the Airtable record to set Status = "Escalated".

Before building, write down your scoring criteria. This is the most important step. Example for a B2B agency:

IDEAL CUSTOMER PROFILE:
- Industry: Professional services, e-commerce, healthcare,
  real estate (20 points)
- Company Size: 10-200 employees (20 points)
- Revenue: $500K - $20M annual (20 points)
- Decision Maker: Owner, CEO, VP, Director (15 points)
- Engagement: Visited pricing page, downloaded resource,
  attended webinar (15 points)
- Budget Mentioned: Yes (10 points)
- Timeline: Within 30 days (10 points)

DISQUALIFIERS (score = 0):
- Student/job seeker
- Competitor
- Outside service area
- Requesting something you don't offer

Customize this for YOUR business. The AI will use these criteria to score leads.

After the lead enters (webhook, form, or CRM trigger), add company enrichment to get more data for scoring.

Using Clearbit (now part of HubSpot): Add "HTTP > Make a Request":

URL: https://company.clearbit.com/v2/companies/find
Method: GET
Query String: domain={{extractDomain(lead_email)}}
Headers: Authorization: Bearer YOUR_CLEARBIT_API_KEY

This returns: company name, industry, employee count, estimated revenue, location, tech stack, social profiles.

Using Apollo.io: Similar API call to https://api.apollo.io/v1/people/match with the lead's email.

Free alternative: Skip enrichment and rely solely on form data + AI analysis. The AI can still infer a lot from the company name and email domain.

Add "OpenAI > Create a Chat Completion":

Model: gpt-4o
Temperature: 0.3

System Prompt:
You are a lead qualification AI for [YOUR COMPANY],
a [YOUR SERVICE] company. Score incoming leads from
1-100 based on how well they match our Ideal Customer
Profile.

SCORING CRITERIA:
[PASTE YOUR ICP FROM STEP 1]

SCORING RULES:
- Add points for each matching criterion
- Subtract 10 points for each mismatch
- Score 0 for disqualified leads
- Be conservative — only score 80+ if multiple strong
  signals are present
- Consider the email domain: @gmail/@yahoo = smaller
  business, @company.com = likely established

Return a JSON object:
{
  "score": 85,
  "tier": "hot|warm|cold|disqualified",
  "reasoning": "Brief explanation of scoring",
  "company_size_estimate": "small|medium|large",
  "industry_match": true/false,
  "recommended_action": "What should sales do next",
  "personalized_angle": "How to approach this specific lead"
}

User Prompt:
NEW LEAD:
Name: {{lead_name}}
Email: {{lead_email}}
Phone: {{lead_phone}}
Company: {{lead_company}}
Message/Inquiry: {{lead_message}}

ENRICHMENT DATA (if available):
Industry: {{clearbit.industry}}
Employees: {{clearbit.employees}}
Revenue: {{clearbit.estimatedAnnualRevenue}}
Location: {{clearbit.location}}
Tech Stack: {{clearbit.tech}}

Add a "JSON > Parse JSON" module, then a "Router" with three paths:

Path 1 — HOT LEAD (Score 80-100):

• Slack: Post to #hot-leads with full details and the AI's recommended approach
• Twilio SMS: Text your sales rep: "HOT LEAD: {{name}} from {{company}} (Score: {{score}}). {{personalized_angle}}. Call within 5 minutes!"
• HubSpot: Create/update contact with Lead Status = "Hot", Lead Score = {{score}}, Priority = "High"
• Gmail: Send the instant follow-up email (tie into Blueprint #1)

Path 2 — WARM LEAD (Score 40-79):

• HubSpot: Create contact, Lead Status = "Warm", enroll in a 5-email nurture sequence
• Gmail: Send a personalized but lower-urgency response within 24 hours
• Slack: Post to #leads (informational, no urgency)

Path 3 — COLD LEAD (Score 0-39):

• HubSpot: Create contact, Lead Status = "Cold", add to newsletter list
• Gmail: Send a generic "thanks for your interest" email with helpful resources
• No sales follow-up unless they engage further

For warm leads (score 40-79), create a 5-email drip sequence spaced over 14 days:

Day 1:  "Thanks for reaching out" + helpful resource
        (blog post, guide, case study)
Day 3:  Social proof email (testimonial, case study
        with results)
Day 7:  Value-add email (tip or insight related to
        their industry/pain point)
Day 10: Soft CTA email ("Here's what working with us
        looks like" + process overview)
Day 14: Direct CTA ("Ready to explore this further?
        Book a call: [LINK]")

Build this as a separate Make scenario triggered by a schedule that checks for warm leads at each stage. Use a "Nurture Stage" column in your CRM/sheet to track progress.

Create a Lead Scoring Accuracy Google Sheet. For each scored lead, track: AI Score, Tier, Outcome (Closed/Lost/Unresponsive), Revenue if closed.

Monthly, review the data: Are high-scored leads actually closing? Are low-scored leads sometimes converting? Adjust your ICP criteria and AI prompt based on real results.

Target: 80%+ accuracy within 2-3 months of refinement.

Create scenario: Testimonial Collector. Schedule: Daily at 10 AM.

Module: "HTTP > Make a Request" to the Google Places API:

URL: https://maps.googleapis.com/maps/api/place/details/json
Method: GET
Query String:
  place_id: YOUR_GOOGLE_PLACE_ID
  fields: reviews
  key: YOUR_GOOGLE_MAPS_API_KEY

To find your Place ID: Go to Google's Place ID Finder and search your business.

Add "JSON > Parse JSON" to extract the reviews array.

Add an "Iterator" to loop through each review.

Add a "Filter":

Condition 1: rating >= 4
Condition 2: time > {{last_check_timestamp}}
(Store the last check timestamp in a Make data store
 or Google Sheet cell that you update after each run)

Alternative sources for reviews:

• Yelp: Use the Yelp Fusion API (/businesses/{id}/reviews)
• Form-submitted testimonials: Use a Typeform/Tally "Testimonial" form as a webhook trigger
• Email-submitted: Watch for emails with subject containing "testimonial" or "review"

Add "OpenAI > Create a Chat Completion":

Model: gpt-4o-mini
Temperature: 0.7

System Prompt:
You are a social media content specialist. You take
customer reviews/testimonials and format them into
engaging social media posts. Create 3 versions:

1. INSTAGRAM POST: Use the review as a quote graphic
   caption. Add context, a brief intro, and relevant
   hashtags. 100-150 words. Include emojis sparingly.

2. LINKEDIN POST: Professional tone. Frame the
   testimonial within a narrative about delivering
   results. 150-200 words. End with a CTA.

3. FACEBOOK POST: Conversational, community-focused.
   Thank the reviewer by name. Celebrate the win.
   100-130 words.

Also provide:
4. QUOTE EXCERPT: The most powerful 1-2 sentences
   from the review, perfect for a graphic.
5. IMAGE HEADLINE: A 3-5 word headline to overlay
   on the testimonial graphic (e.g., "Real Results
   That Matter")

Return as JSON:
{
  "instagram": "...",
  "linkedin": "...",
  "facebook": "...",
  "quote_excerpt": "...",
  "image_headline": "..."
}

User Prompt:
REVIEW TO FORMAT:
Author: {{review.author_name}}
Rating: {{review.rating}}/5 stars
Review Text: {{review.text}}

Our business: [YOUR COMPANY] - [YOUR SERVICE]

Using Placid.app (recommended):

First, create a template in Placid with your brand colors, logo, and a testimonial layout. Your template should have dynamic fields for: quote text, author name, star rating, headline.

In Make.com, add "HTTP > Make a Request":

URL: https://api.placid.app/api/rest/images
Method: POST
Headers:
  Authorization: Bearer YOUR_PLACID_TOKEN
  Content-Type: application/json
Body:
{
  "template_uuid": "YOUR_TEMPLATE_ID",
  "layers": {
    "quote": {"text": "{{json.quote_excerpt}}"},
    "author": {"text": "- {{review.author_name}}"},
    "stars": {"text": "{{review.rating}} stars"},
    "headline": {"text": "{{json.image_headline}}"},
    "logo": {"image": "https://yoursite.com/logo.png"}
  }
}

Placid returns an image URL that you can use in the social post.

Free alternative (Canva): Use the Canva Connect API or manually create images using templates. Less automated but works at lower volume.

Simplest alternative: Skip image generation entirely. Just post the text with your logo as the image. Many businesses do this successfully.

Add "Airtable > Create a Record" in a Testimonial Queue table:

Fields:
  Review Author:     {{review.author_name}}
  Review Text:       {{review.text}}
  Rating:            {{review.rating}}
  Instagram Copy:    {{json.instagram}}
  LinkedIn Copy:     {{json.linkedin}}
  Facebook Copy:     {{json.facebook}}
  Quote Excerpt:     {{json.quote_excerpt}}
  Image URL:         {{placid_image_url}}
  Status:            "Pending Approval"
  Detected Date:     {{now}}
  Published Date:    (empty)
  Source:            "Google Reviews"

Add "Slack > Create a Message" in #content-approval:

:star: *New Testimonial Ready for Publishing*

*From:* {{review.author_name}} ({{review.rating}} stars)
*Review:* "{{review.text}}"

*Generated Posts:*

:camera: *Instagram:*
{{json.instagram}}

:briefcase: *LinkedIn:*
{{json.linkedin}}

:blue_book: *Facebook:*
{{json.facebook}}

:frame_with_picture: *Image:* {{placid_image_url}}

React :white_check_mark: to approve and schedule all posts
React :pencil2: to edit in Airtable first
React :x: to skip this testimonial

Create scenario: Testimonial Publisher. This can be triggered two ways:

Option A — Slack Reaction Trigger: Use "Slack > Watch Reactions" and filter for :white_check_mark: on messages in #content-approval. When detected, search Airtable for the matching testimonial and update status to "Approved."

Option B — Airtable Status Change (simpler): Schedule a scenario every 15 minutes that searches for records where Status = "Approved" and Published Date is empty.

For each approved testimonial, use a Router to post to each platform:

Instagram: "Buffer > Create a Post" → select Instagram profile, paste Instagram copy, attach image URL.

LinkedIn: "Buffer > Create a Post" → select LinkedIn profile, paste LinkedIn copy.

Facebook: "Buffer > Create a Post" → select Facebook page, paste Facebook copy, attach image.

After all posts are scheduled, update Airtable: Status = "Published", Published Date = today.

Create a monthly scenario that pulls engagement metrics from Buffer (or directly from platform APIs) for all published testimonial posts. Store in Airtable: Likes, Comments, Shares, Impressions per post.

This tells you which testimonials resonate most with your audience and what type of reviews make the best social content.