# Make Automations

> Visual, no-code workflows in Make.com that move data between your apps without writing any code.

Page: https://mburhan.com/tag/make

17 case studies in full below.

# WidowWise Platform Automation, Data Integrity & Dashboard Modernization

> Repairing and expanding a connected learning platform with automated enrollment synchronization, accurate reporting, and certificate delivery.

Section: Make Automations

Page: https://mburhan.com/case/widowwise-platform-automation-data-integrity-dashboard-moder

## 1. Overview

Wings for Widows is a Minnesota-based nonprofit that provides free one-to-one financial coaching to widows through a network of approximately 150–170 volunteer CFP advisors. Its digital learning operations run through two distinct programs: WidowWise University (WWU), which provides free and scholarship-funded courses, and Advising Through Widowhood (ATW), a separate paid financial advisor certificate program.

The platform uses Teachable for course delivery, Airtable for operational data and dashboards, Make.com for email and certificate workflows, and Mailchimp for student and advisor communications.

The engagement focused on reverse-engineering and repairing an existing automation system, resolving recurring data and dashboard problems, improving enrollment synchronization, and expanding reporting and certificate automation.

**Client:** Wings for Widows **Platform:** WidowWise / WidowWise University **Additional Program:** Advising Through Widowhood (ATW) **Industry:** Nonprofit · Financial Education · Professional Training

## 2. The Problem

The existing system had recurring synchronization and reporting problems that affected enrollment records, dashboard accuracy, and student completion workflows.

The main challenges included:

- **Inaccurate dashboards:** Engagement status fields were sometimes blank, causing totals and charts to show incorrect figures.
- **Duplicate enrollment records:** The original synchronization logic could overwrite previous enrollment history when a student enrolled in the same course more than once.
- **Unreliable data synchronization:** Teachable enrollment data was not consistently matched to the correct Airtable records.
- **Manual certificate issuance:** Completed students required a manual certificate process, creating delays and additional administrative work.
- **Data quality issues:** Duplicate registrations, unmatched enrollment records, and incorrectly classified records affected reporting accuracy.
- **Automation ownership risk:** The primary Teachable API secret belonged to the previous developer, creating a dependency for maintaining the synchronization system.

## 3. How It Works

The solution connects the learning platform, operational database, automation workflows, and communication system.

### Step 1 — Teachable to Airtable Synchronization

Teachable provides the course, student, enrollment, completion, and transaction information used by the operational system.

Airtable serves as the central data layer, containing 20 tables covering people, enrollments, completions, products, lessons, modules, transactions, prices, coupons, graduates, and automation errors.

Scheduled JavaScript automations synchronize Teachable information into Airtable.

### Step 2 — Enrollment Matching and Data Integrity

The original enrollment-matching logic used a combination of course and user identifiers. This could cause a new enrollment cycle to overwrite an earlier record.

The matching logic was rebuilt around each enrollment's actual Person and Product relationships.

- Existing records for the same person and course are identified.
- The record with the highest completion percentage is treated as the current enrollment cycle.
- A new record is created only when progress has moved backwards, indicating a genuine restart.
- Historical enrollment information is preserved instead of being overwritten by a duplicate synchronization event.

Additional JavaScript and Airtable field-formatting issues were identified during testing and corrected before production.

**Screenshot to add:** Teachable enrollment records alongside their corresponding Airtable enrollment records. Highlight the Person and Product relationships and the corrected matching logic.

### Step 3 — Engagement Status and Dashboard Accuracy

Dashboard totals were not reconciling because some incoming Teachable records had blank Engagement Status fields.

The synchronization process was updated so Engagement Status is automatically derived from Percent Complete on every sync run.

- Existing records with blank statuses were backfilled using actual completion data.
- The recurring synchronization logic was corrected so new records receive the appropriate status automatically.
- A separate In Progress metric was fixed after identifying an incorrect filter and inconsistent Percent Complete data.

This removed the need for repeated manual corrections to dashboard records.

**Screenshot to add:** Airtable dashboard showing Total, Completed, In Progress, and Not Started, alongside the Engagement Status and Percent Complete fields.

### Step 4 — Graduation and Certificate Automation

A certificate automation pipeline was built around the student's completion status.

When Engagement Status changes to Completed:

1. A sequential Certificate ID is generated.
2. Certificate and mailing details are sent to C&M Printing.
3. Chris receives the CFP continuing-education filing information.
4. The process is gated to prevent certificates from being issued when registration data is incomplete or mismatched.

The workflow also addressed real completion-record issues, including students stuck at 99% and certificate records requiring manual intervention.

**Screenshot to add:** Make.com certificate automation scenario, the generated Certificate ID in Airtable, and an example of the certificate notification workflow.

### Step 5 — Dashboard Expansion

Several dashboards were built or improved to provide more reliable operational reporting.

- **ATW Enrollments:** Corrected metric-card calculations so dashboard figures reconcile.
- **All Courses (Select to Filter):** Created a unified dashboard with a live course-selection dropdown.
- **ATW Progression (Pace & Stuck Points):** Rebuilt based on detailed client feedback, including a clearer advisor grid, normalized completion percentages, and enrollment information.
- **Percent Complete (Normalized):** Added a safety-net formula to protect against incorrectly scaled Teachable values.

**Screenshot to add:** The ATW Enrollments dashboard, All Courses dashboard with its course selector, and ATW Progression dashboard.

### Step 6 — Automation Ownership and Reliability

The Teachable API credential previously belonged to the original developer, creating an operational dependency.

A new independently owned API secret was created, and the synchronization automation was repointed to use it.

This restored the client's control over the integration and reduced dependency on the previous developer.

**Screenshot to add:** Teachable API integration configuration and the relevant Make.com or Airtable automation scenario. Do not expose API keys or credentials.

## 4. The Result

The engagement transformed a recurring maintenance problem into a more reliable learning and reporting system.

Enrollment synchronization was rebuilt around actual student and course relationships, preserving enrollment history and reducing the risk of duplicate records. Dashboard calculations were corrected, and Engagement Status is now automatically derived from completion data during synchronization.

Certificate issuance was automated through sequential Certificate IDs, print-partner notifications, and completion checks. Additional dashboards improved visibility into course enrollment, advisor progression, and student completion.

The platform's API ownership was also transferred away from the previous developer, giving the client independent control over the integration.

## 5. Results & Metrics

The source documents specific implementation outcomes rather than a complete before-and-after performance study.

| Area | Documented outcome |
| --- | --- |
| Airtable operational database | 20 tables |
| Enrollment synchronization | Rebuilt around Person and Product relationships |
| Engagement Status | Automatically derived on every sync |
| Dashboard accuracy | Metric-card calculations corrected |
| Certificate workflow | Sequential Certificate ID and automated notifications |
| Dashboard expansion | ATW Enrollments, All Courses, and ATW Progression |
| API ownership | New independently owned Teachable API secret |

## 6. Tech Stack

- **Teachable:** Learning management system hosting courses and enrollment information.
- **Airtable:** Central operational database, enrollment records, completion tracking, and dashboards.
- **Airtable Automations:** JavaScript-based scheduled synchronization and data processing.
- **Make.com:** Outbound email automation and graduation/certificate workflows.
- **Mailchimp:** Student and advisor communications, including welcome, reminder, continuation, completion, and access-related emails.

## 7. Where This Pattern Applies

- **Nonprofit Organizations:** Manage scholarship programs, participant records, course completion, and automated communications.
- **Educational Institutions:** Synchronize student enrollments, academic progress, certificates, and reporting dashboards.
- **Professional Certification Providers:** Automate eligibility checks, completion tracking, certificate generation, and continuing-education records.
- **Online Learning Platforms:** Maintain accurate student histories across repeat enrollments, course restarts, and completion cycles.
- **Coaching Organizations:** Track client and advisor progress, program participation, and follow-up workflows.
- **Training and Development Teams:** Combine learning platforms with operational databases to monitor employee training and certification.

This pattern is useful for organizations that rely on multiple connected platforms to manage people, enrollments, learning progress, and communications. By improving synchronization, data integrity, and workflow automation, they can build a more dependable operational system around their existing tools.

---

# Automated Order-to-Task Management and Asana Synchronization

> Automation that turns sales orders into Asana tasks, with deadlines and project updates handled automatically.

Section: Make Automations

Page: https://mburhan.com/case/automated-order-to-task-management-and-asana-synchronization

## Overview

This solution connects NetSuite sales orders with Asana, automating task creation, deadline tracking, and project organization. It keeps order information and operational tasks aligned, reduces repetitive manual updates, and helps teams stay organized.

## The Problem

Sales orders live in NetSuite, but the work needed to fulfil them is managed in Asana. Moving information between the two systems means manually creating tasks, transferring order details, checking deadlines, and keeping project sections organized.

Tasks can be duplicated, important order details can be missed, and statuses can fall out of date. When several projects are involved, keeping everything aligned becomes another job in itself.

## How It Works

The solution uses three connected Make scenarios, each handling a different part of the operational workflow.

1. **Receive sales order information.** A custom webhook receives sales order data originating from NetSuite and starts the automation.
2. **Process the order items.** The workflow iterates through the line items and separates regular Asana items from TM Engraving items, sending each through its configured processing route.
3. **Prepare structured task details.** It combines item names, descriptions, quantities, engraving notes, and shipping methods where available.
4. **Check for existing tasks.** Before creating anything, the automation searches Asana using the sales order number and purchase order number.
5. **Create or update the task.** If no matching task exists, a new one is created. If a matching task already exists, its notes are updated instead of creating a duplicate.
6. **Monitor deadlines and statuses.** A second scenario retrieves active tasks from two configured Asana projects and evaluates their due dates, current sections, and existing status fields.
7. **Update only when necessary.** Conditional rules calculate the appropriate status based on configured date and section conditions. The automation updates the custom field only when a change is required and skips unnecessary updates
8. **Organize tasks through events.** A third scenario listens for Asana webhook events, identifies the associated task and project, determines the appropriate destination section, and moves the task using the Asana API..

Image (https://mburhan.com/uploads/a60dd6b84104c1fa716c6f16.png)

Image (https://mburhan.com/uploads/9452d59fd93efd5cb5f2b8a9.png)

## The Result

The integrated automation manages the complete workflow between NetSuite, Asana, and Ashore. It automatically creates and updates Asana tasks from eligible sales orders, checks deadlines, updates task statuses, and organizes tasks into the appropriate project sections based on Ashore updates. This reduces manual task management, improves project organization, and keeps information synchronized across all three platforms.

### Daily Automation Output

| Metric | Combined Result |
| --- | --- |
| Successful workflow executions | 65 per day |
| Successful execution rate | 100% of displayed runs |
| Average execution time | 1.66 seconds |
| Tasks created | 4 |
| Existing tasks updated | 2 |
| Scheduled deadline checks | 24 per day |

*Note:Metrics are based on the observed day and may vary depending on daily sales order volume, task updates, and incoming Ashore events.*

### Daily Automation Activity

Image (https://mburhan.com/uploads/badae2adb00e84f9f3367811.png)

## Tech Stack

- **Make:** Runs all three automation scenarios and coordinates the workflow logic, routers, filters, iterators, and conditional operations.
- **NetSuite:** Supplies sales order information, customer details, and order line items.
- **Asana:** Manages operational tasks, project sections, due dates, notes, and custom status fields.
- **Asana API:** Handles task searches, creation, updates, status changes, and section assignments.
- **Webhooks:** Trigger the scenarios when sales order information or supported Asana task events are received.
- **Routers, Filters, Iterators, and Variables:** Control processing paths, handle line items, evaluate conditions, and determine the appropriate task updates.

## Where This Pattern Applies

This solution goes beyond task creation. It keeps sales orders, deadlines, task statuses, and project activities connected, helping teams stay organized across their daily operations.

Imagine a business receiving a new customer order through its CRM. The automation takes the order information, identifies the required work, checks whether a corresponding project task already exists, creates or updates it, assigns the relevant deadline, and keeps its status aligned as work progresses.

The same approach can be adapted to different business operations:

- **Sales:** Convert new opportunities and closed deals into structured tasks and follow-up activities.
- **Manufacturing:** Turn production orders into operational tasks with deadlines and progress tracking.
- **E-commerce:** Coordinate order fulfilment, packaging, and shipping activities.
- **Insurance:** Convert new claims into investigation and documentation tasks.
- **HR & Recruiting:** Organize candidate onboarding, interview activities, and employee documentation.
- **Finance:** Coordinate invoice approvals, payment processing, and reconciliation tasks.
- **Logistics:** Manage shipment preparation, delivery coordination, and dispatch activities.
- **Customer Support:** Convert incoming requests into trackable support tasks.
- **Project Management:** Keep tasks, deadlines, statuses, and project sections synchronized across teams.
- **Professional Services:** Coordinate client projects, deliverables, and internal assignments.

The underlying pattern remains the same: receive information, process it, check for existing records, create or update tasks, evaluate deadlines, synchronize statuses, and organize work based on events.

Whatever systems a business uses, the objective is the same: keep operational information connected and let automation handle the repetitive coordination.

---

# Automated NetSuite to ShipStation Order Processing

> Automation that sends eligible NetSuite sales orders to ShipStation, prepares shipping details, and updates order status automatically.

Section: Make Automations

Page: https://mburhan.com/case/automated-netsuite-to-shipstation-order-processing

### Overview

This solution connects NetSuite with ShipStation through Make. It identifies eligible sales orders, prepares their customer, address, item, and shipping details, creates the corresponding orders in ShipStation, and updates NetSuite to record processing.

### The Problem

Sales orders are managed in NetSuite, while shipment preparation takes place in ShipStation. Transferring order details between the two systems requires staff to enter customer information, billing and shipping addresses, line items, quantities, prices, and shipping services.

This repetitive work takes time and creates opportunities for incorrect item details, shipping selections, or incomplete order records. Teams also need a reliable way to identify which orders and line items have already been processed.

### How It Works

The solution uses a Make scenario to handle the order-processing workflow.

1. **Monitor sales orders.** Make watches a configured NetSuite saved search for sales orders that have been modified.
2. **Check order eligibility.** The workflow checks whether the order is marked to be sent to ShipStation and has not already been marked as created there.
3. **Retrieve order details.** It fetches the complete sales order, including customer information, billing and shipping addresses, dates, totals, and line items.
4. **Prepare order information.** The workflow collects the order details and processes its line items, including item names, descriptions, quantities, and prices.
5. **Format item data.** OpenAI converts the NetSuite line-item data into the structure required by the ShipStation API.
6. **Identify the shipping service.** The workflow reads the shipping method from the order items and maps it to the corresponding ShipStation service code. If no method is available, it uses the configured Ground default.
7. **Create the ShipStation order.** An HTTP request sends the prepared customer, address, item, payment, tax, and shipping information to ShipStation.
8. **Update NetSuite records.** After the order-creation step succeeds, the workflow updates the NetSuite sales order and marks the relevant line items as processed.

Image (https://mburhan.com/uploads/393a363198ccacc28a6e3d76.png)

Image (https://mburhan.com/uploads/680be48805644d93a72d9d33.png)

### The Result

The automation connects order entry with shipment preparation, reducing the need to manually transfer sales order information between NetSuite and ShipStation. It prepares item and shipping details, creates ShipStation orders, and records processing status back in NetSuite. This helps reduce repetitive data entry and keeps order-processing records aligned across both systems.

**Daily Automation**

| Metric | Observed Output |
| --- | --- |
| Emails processed | 7/day (average) |
| Successful runs | 96/day |
| Run frequency | 15 minutes |
| Success rate | 100% |
| Execution time | 1.5 seconds |

*Note:Metrics are based on the observed execution history and may vary depending on order activity and processing time.*

Image (https://mburhan.com/uploads/b19353f0ce90789b18b23bd6.png)

Image (https://mburhan.com/uploads/dd0754ad802944a6786302f4.png)

### Tech Stack

- **Make:** Runs the automation and coordinates order processing, routing, data preparation, and conditional operations.
- **NetSuite:** Provides sales orders, customer details, addresses, item information, and shipping data.
- **ShipStation:** Receives and manages sales orders for shipment processing.

The solution works with the existing NetSuite and ShipStation setup, without requiring teams to replace their systems or learn a new order-management platform.

### Where This Pattern Applies

This approach connects order records with downstream fulfilment activities, ensuring that information is transferred, processed, and tracked automatically.

Imagine a wholesale business receiving customer orders through its ERP system. The automation collects the order details, formats product and shipping information, sends the order to its fulfilment platform, and updates the original record once processing is complete.

The same pattern can be adapted to:

- **E-commerce:** Transfer online orders into shipping and fulfilment platforms.
- **Wholesale:** Process bulk customer orders and prepare shipment records.
- **Manufacturing:** Send production orders to operational and dispatch systems.
- **Retail:** Coordinate store orders with warehouse fulfilment.
- **Logistics:** Transfer shipment details between order and transport systems.
- **Healthcare Supply:** Coordinate medical supply orders with distribution systems.

The reusable pattern remains the same: monitor incoming orders, validate eligibility, prepare structured data, send it to the fulfilment platform, and update the original system to reflect processing.

---

# Automated NetSuite Billing and Shipment Processing

> Automation that extracts invoice and shipment details from incoming emails, matches them with NetSuite records, and prepares shipment notifications.

Section: Make Automations

Page: https://mburhan.com/case/automated-netsuite-billing-and-shipment-processing

### Overview

This solution connects Microsoft Outlook, OCR.space, OpenAI, and NetSuite through Make. It processes incoming billing emails and PDF attachments, extracts purchase order numbers, tracking IDs, and vendor information, matches the information with NetSuite transactions, and prepares shipment-related email notifications. It also sends an alert when OCR processing encounters an error.

### The Problem

Billing teams manually review incoming emails, download invoices and shipment documents, extract key details, and match them with NetSuite records. This repetitive process takes time and increases the risk of missing information or incorrect transaction matching.

### How It Works

The solution uses a Make scenario to process incoming billing emails and their attachments.

1. **Monitor Billing Emails.** Microsoft Outlook watches the configured billing inbox for incoming messages.
2. **Apply Email Conditions.** The workflow checks sender and subject details to determine which messages should proceed.
3. **Retrieve Attachments.** It lists the available attachments and downloads the relevant files.
4. **Filter PDF Documents.** PDF attachments proceed through the document-processing route, with a short delay before extraction.
5. **Extract Document Text.** OCR.space processes the PDF and returns its extracted text.
6. **Handle OCR Errors.** If the OCR request encounters an error, the workflow sends an email alert to the configured recipient.
7. **Prepare Extraction Inputs.** The email preview and extracted PDF text are stored for further processing.
8. **Extract Purchase Order and Tracking Details.** OpenAI identifies purchase order numbers and tracking IDs from the available email and document content.
9. **Identify Vendor Information.** A separate OpenAI step extracts vendor details, and the returned information is parsed into structured fields.
10. **Search NetSuite Transactions.** The workflow searches NetSuite for records matching the extracted information and retrieves the relevant transaction details.
11. **Prepare Item Information.** Related transaction items are collected and processed into a structured list for the notification.
12. **Prepare Shipment Emails.** The workflow combines the retrieved transaction, item, and shipment information to prepare the relevant email.
13. **Send Notifications.** Microsoft Outlook sends the shipment-related email using the prepared information.

Image (https://mburhan.com/uploads/caed3e789f10aa5f09a5d07d.png)

Image (https://mburhan.com/uploads/11215d54721d4d0d7714a452.png)

### The Result

The automation connects incoming billing documents with the corresponding NetSuite records and shipment notifications. Instead of manually reviewing every email, downloading documents, extracting details, and searching transactions, the workflow handles these steps automatically. It also provides an email alert when OCR processing fails, helping the team identify document-processing issues.

**Execution Metrics**

| Metric | Result |
| --- | --- |
| Total executions | 164 |
| Successful executions | 158 |
| Success rate | \~95% |
| Average execution time | 17.15 seconds |

*Note:Metrics are based on the available execution logs and may vary depending on email volume, attachment processing, and document complexity.*

Image (https://mburhan.com/uploads/a748080b643f2707522772e9.png)

### Tech Stack

**Make:** Coordinates the complete workflow, including email routing, attachment processing, data extraction, transaction matching, and error handling.

**Microsoft Outlook:** Monitors the billing inbox, retrieves email attachments, and sends shipment notifications and OCR error alerts.

**OCR.space API:** Extracts readable text from PDF attachments for further processing.

**OpenAI:** Extracts purchase order numbers, tracking IDs, and vendor information from email and document content.

**NetSuite:** Provides transaction and item records used to match extracted billing and shipment information.

**JavaScript:** Supports custom data processing and prepares structured item information for email notifications.

The team can continue using Outlook and NetSuite without replacing its existing email or business management systems.

### Where This Pattern Applies

This is not limited to billing and shipment processing. Imagine an e-commerce business receiving supplier invoices, delivery documents, and tracking information through email. The automation extracts the relevant details, finds matching order records, and prepares the next notification without requiring someone to process every document manually.

The same approach can be adapted to:

- **E-commerce:** Order and shipment document processing
- **Logistics:** Delivery documents and tracking details
- **Finance:** Invoice and purchase order processing
- **Procurement:** Supplier document management
- **Distribution:** Shipment records and customer notifications
- **Healthcare Supply:** Medical supply invoices and delivery documentation

The reusable pattern remains the same: receive documents, extract information, identify relevant details, match existing records, and trigger the next action. What changes is the document type, the system being searched, and the action that follows.

---

# AI Task Delegator: Slack to Monday.com

> Automating the conversion of Slack requests into structured and assigned Monday.com tasks.

Section: Make Automations

Page: https://mburhan.com/case/ai-task-delegator-slack-to-monday-com

## 1. Overview

This automation connects Slack with Monday.com to convert qualifying messages into structured tasks. An AI agent extracts task details from the original Slack message, while configured mappings determine the appropriate Monday.com board and task owner. The workflow also creates explicitly listed subtasks and sends a confirmation back to Slack.

## 2. The Problem

Teams often share work requests through Slack, but important action items can get buried in conversations. Manually converting these requests into Monday.com tasks requires reviewing messages, extracting details, selecting the correct board, and assigning owners. This repetitive process takes time and can result in inconsistent task information or missed action items.

## 3. How It Works

1. **Capture Slack Event:** The workflow detects qualifying Slack messages or reactions through a configured event trigger.
2. **Retrieve Original Message:** It retrieves the complete Slack message to provide context for AI processing.
3. **Extract Task Information:** The AI agent generates a task title and description and identifies mentioned Slack user IDs and explicitly listed subtasks.
4. **Retrieve User Details:** The workflow uses extracted Slack IDs to retrieve the corresponding user information where required.
5. **Determine Board and Owner:** Configured user and channel mappings identify the appropriate Monday.com board, group where applicable, and task owner.
6. **Create Monday.com Task:** The workflow creates the main task using the extracted title and adds its description and original Slack message context.
7. **Create Subtasks:** If the request contains explicitly listed subtasks, the workflow iterates through them and creates them under the main task.
8. **Send Slack Confirmation:** After task creation, the workflow sends a confirmation in the original Slack conversation with a link to the Monday.com task.

Image (https://mburhan.com/uploads/0ca02087e791d6fbe30f0095.png)

Image (https://mburhan.com/uploads/23feb196cde10ae564ef87f7.png)

## 4. The Result

The automation connects Slack requests directly with Monday.com task management. It reduces manual task entry, structures incoming requests, applies configured board and owner mappings, and preserves the original conversation context. It also supports automatic subtask creation and sends confirmation through Slack.

### Execution Metrics

| Metric | Result |
| --- | --- |
| Total Executions | 4,856 |
| Successful Executions | 4,826 |
| Failed Executions | 16 |
| Success Rate | 99.4% |
| Average Execution Time | 0.63 seconds |

Image (https://mburhan.com/uploads/f154d3beae60e55de73746d1.png)

*Metrics are based on the available execution logs and may vary depending on message volume, task complexity, and the number of subtasks processed.*

## 5. Tech Stack

**Make:** Coordinates the automation, processes Slack events, manages AI extraction, handles routing, and creates Monday.com tasks and subtasks.

**Slack:** Provides the triggering messages or reactions, original conversation context, user information, and task confirmations.

**OpenAI:** Uses GPT-4.1 mini and GPT-4.1 nano to extract and structure task information from Slack messages.

**Monday.com:** Receives the structured tasks, mapped owners, and explicitly listed subtasks.

## 6. Where This Pattern Applies

This automation pattern can be applied wherever teams receive work requests through communication platforms and need to organize them in task-management systems. Examples include internal operations, customer support, marketing coordination, project management, and administrative task tracking.

---

# From a Signed DocuSign Contract to a Master Sheet Row and an Itinerary Slide

> Turning a signed DocuSign travel contract into a master sheet row, a filed contract and an itinerary slide, automatically.

Section: Make Automations

Page: https://mburhan.com/case/make-docusign-contract-to-master-sheet-and-itinerary-slide

## Project Overview

This Make automation supports operations for a group travel company that manages college formal events.

When a group signs a travel contract in DocuSign, the workflow processes the completed contract and supports three follow-up tasks: recording trip details in the master operations spreadsheet, filing the signed contract in the group's Google Drive folder, and producing a Friday, Saturday, and Sunday itinerary slide.

**Tools:** Make, DocuSign, Google Apps Script, Anthropic Claude (`claude-sonnet-4-6`), Google Sheets, Google Slides, and Google Drive.

## 01. The Challenge

Signed travel contracts contain information that must be transferred into several operational resources, including:

- Hotel names and room counts
- Check-in ages
- Buses and venues
- Event times
- Food and bar packages
- Payment and task due dates

Manually transferring these details into the master sheet, filing the contract, and building a customer-facing itinerary is repetitive and can lead to errors.

## 02. The Solution

A Make scenario automates the process after a DocuSign envelope is completed. It downloads the signed document, obtains structured contract data through a Google Apps Script web app, and uses Claude to generate the three-day itinerary text.

The workflow then routes the results into three paths: a new-contract path, an addendum path, and an archive path.

## 03. How It Works

### Step 1: Detect the Signed Contract

The workflow starts when a DocuSign envelope is completed.

### Step 2: Download the Document

Make downloads the signed contract for further processing.

### Step 3: Extract Contract Information

An HTTP request sends the document to a Google Apps Script web app, which returns the contract fields as structured data.

### Step 4: Generate Itinerary Text

Claude uses the structured fields to write the itinerary content for Friday, Saturday, and Sunday.

### Step 5: Route the Results

A router directs the workflow into three paths:

- **New Contract:** Handles the new-contract path.
- **Addendum:** Handles the addendum path.
- **Archive:** Handles the archive path.

The scenario connects with Google Sheets, Google Slides, and Google Drive as part of the downstream processing.

Image: Part of the Make scenario: the DocuSign trigger and download, the HTTP call to the Apps Script web app, Claude, and a router that splits into Google Sheets, Slides and Drive paths. (https://mburhan.com/case-content/make-portfolio/image11.png)

## 04. Workflow Architecture

The workflow uses a router to separate the processing paths after the contract information and itinerary text have been prepared.

Image (https://mburhan.com/uploads/6f293dcea5a8e6d363d0c011.png)

## 05. Example Output: Three-Day Itinerary

The example itinerary slide presents a group's Friday, Saturday, and Sunday schedule. The supplied screenshot has group, date, hotel, and company details blurred for privacy.

**Suggested placement:** Include the itinerary screenshot here, after the workflow architecture section, to show an example of the generated output.

Image: An example three-day itinerary slide (group, dates, hotel and company details blurred for privacy). (https://mburhan.com/case-content/make-portfolio/image12.png)

## 06. Tools and Integrations

- **Make:** Coordinates the automation and routes the workflow.
- **DocuSign:** Triggers the process when a contract envelope is completed and provides the signed document.
- **Google Apps Script:** Returns contract fields as structured data.
- **Anthropic Claude:** Generates the three-day itinerary text.
- **Google Sheets:** Supports master operations data.
- **Google Slides:** Supports the itinerary slide.
- **Google Drive:** Supports contract filing.

## 07. Outcome

The workflow automates key steps following contract completion, connecting signed-document processing with structured trip data, itinerary text generation, and downstream document handling.

---

# A Slack Bot That Answers Trip Questions from an Ops Master Sheet

> A Make scenario that lets a team member ask a plain-English trip question in Slack and get an answer drawn only from the ops master sheet.

Section: Make Automations

Page: https://mburhan.com/case/make-slack-bot-trip-questions-from-ops-master-sheet

## Project Overview

This internal operations tool helps a group travel team find trip information using plain-English questions in Slack, without manually searching through a large Google Sheets workbook.

The team stores trip information in the `MASTER` tab of the `Master Ops Fall 26/Spring27` workbook. Each row represents a group trip and contains information about dates, destinations, operations coordinators, sales representatives, contracts, hotels and rooming, transport, events, task due dates, and payment status.

**Tools:** Make, Slack, Google Sheets, and Anthropic Claude (`claude-sonnet-4-6`).

## 01. The Problem

The operations master sheet contains more than 55 labelled fields per trip, spanning columns A to BH.

Finding a specific detail—such as a group's hotel information or room counts—requires locating the correct trip row and navigating to the relevant column. This makes answering everyday operational questions more time-consuming.

## 02. The Solution

A six-module Make scenario connects Slack with Google Sheets and Claude to process questions and return relevant trip information.

The workflow:

- Receives the question and Slack channel through a webhook.
- Uses Claude to convert the question into structured search terms.
- Searches the master sheet for matching trips.
- Combines the matching rows into readable text.
- Uses Claude again to generate an answer based only on the retrieved information.
- Posts the answer back to the same Slack channel.

## 03. How It Works

### Step 1: Receive the Question

A custom webhook receives the incoming question and the Slack channel information.

### Step 2: Identify the Search Terms

Claude interprets the plain-English question and converts it into structured search terms that can be used to find relevant trips.

### Step 3: Search Google Sheets

The scenario searches the operations master sheet for trips matching the extracted criteria.

### Step 4: Format the Matching Results

The matching spreadsheet rows are combined into readable text using a text aggregator.

### Step 5: Generate the Answer

Claude uses the retrieved text to answer the original question. The answer is restricted to the information provided by the matching spreadsheet results.

### Step 6: Reply in Slack

The final answer is posted back to the same Slack channel where the question originated.

Image: The Make scenario: a custom webhook, Claude turning the question into search terms, a Google Sheets search, a text aggregator, Claude answering from the results, and a Slack message. (https://mburhan.com/case-content/make-portfolio/image13.png)

## 04. Workflow Architecture

Image (https://mburhan.com/uploads/0757e394ec20153ad5a5584e.png)

The scenario separates question interpretation, data retrieval, result formatting, and answer generation into distinct steps.

## 05. Example Use Case

A team member asks:

“How many groups do we have in Nashville from April 9–11, 2027?”

The bot searches for trips matching the destination and dates, then returns the matching groups with their trip dates and destinations in Slack. The example screenshot shows group names blurred for privacy.

Image: An example answer in Slack: the question, the search terms Claude worked out, and the matching groups with their dates and destination (group names blurred for privacy). (https://mburhan.com/case-content/make-portfolio/image14.png)

## 06. Tools and Integrations

- **Make:** Connects the workflow modules and coordinates processing.
- **Slack:** Provides the interface for asking questions and receiving answers.
- **Google Sheets:** Stores the operations master data used to answer questions.
- **Anthropic Claude:** Converts questions into search terms and generates answers from the retrieved results.

## 07. Outcome

The scenario gives the operations team a conversational way to retrieve trip information from a large master sheet. Team members can ask questions in Slack and receive structured answers based on matching spreadsheet records, without manually searching across the workbook.

---

# Newsletter Generator: From a Google Sheets Row to a Draft Campaign

> A Make scenario that turns one row of a Google Sheets newsletter planner into a finished draft campaign in Campaign Monitor, in one of three layouts chosen by the editor.

Section: Make Automations

Page: https://mburhan.com/case/make-newsletter-generator-sheet-to-campaign-monitor

## Project Overview

This Make scenario automates the creation of newsletter draft campaigns using content stored in Google Sheets. Editors prepare the newsletter information in a spreadsheet, select one of three templates, and mark the row for creation. Make then builds the newsletter and creates a draft campaign in Campaign Monitor.

## 01. The Challenge

Creating a newsletter manually requires editors to copy titles, images, excerpts, links, and category labels into an email template. This process must be repeated for news articles, sponsored posts, a destination report, and a podcast episode.

## 02. The Solution

The Make scenario connects Google Sheets with Campaign Monitor to generate a newsletter draft from a single spreadsheet row. It uses the selected template to build the campaign content and updates the row when the process is complete.

## 03. How It Works

### Step 1: Prepare the Newsletter

The editor fills in a Google Sheets row with the content for three news posts, three sponsored posts, a destination report, and a podcast episode.

### Step 2: Select a Template

The editor chooses template 1, 2, or 3 and sets the **Create Newsletter** cell to `Create`.

### Step 3: Find the Requested Row

Make searches the sheet on its schedule for a row marked `Create` and processes one row at a time.

### Step 4: Route to the Selected Layout

A router directs the row to one of three routes based on the selected template number.

### Step 5: Build the Newsletter

A code step assembles the newsletter content, including banners, images, category labels, titles, excerpts, links, and buttons. The layout varies according to the selected template.

### Step 6: Create the Draft Campaign

An HTTP request sends the generated content to the Campaign Monitor API, which creates a draft campaign using the selected template.

### Step 7: Update the Spreadsheet

After the campaign is created, Google Sheets is updated with the status `Done`.

Image: The Make scenario: Google Sheets searches for a row marked Create, a router picks one of three templates, a code step builds the newsletter content, an HTTP call creates the campaign from the template, and Google Sheets updates the row. A Skip step on each route handles errors. (https://mburhan.com/case-content/make-newsletter-generator/image1.png)

## 04. Newsletter Content Structure

The generated newsletter includes:

- A top banner
- Three news posts
- A banner separating content sections
- Three sponsored posts
- A destination report
- A podcast episode
- An additional banner

News and sponsored posts include images, category labels, titles, excerpts, and links. The destination report includes a destination name and description, while the podcast section includes its date, title, description, and listening link.

## 05. Template Options

The scenario supports three newsletter layouts:

- **Template 1:** A three-row layout.
- **Templates 2 and 3:** Mixed layouts with two posts side by side and one centred below, using their respective templates.

## 06. Content Handling

The code includes defaults for missing content. Missing news or sponsored-post images use a default image, missing links point to the main website, and each campaign receives a unique name with a timestamp. The subject line and header date default to the current month and year. Sender details and the subscriber list are also set in the code step.

## 07. Workflow Architecture

Image (https://mburhan.com/uploads/9ea2bb3a7484f334d4e03c96.png)

Each template route builds the campaign content and sends it to Campaign Monitor. A Skip step on each route handles errors.

## 08. Tools and Integrations

- **Make:** Coordinates the workflow, routing, and newsletter generation.
- **Google Sheets:** Stores newsletter content, template selection, and processing status.
- **Campaign Monitor:** Creates the newsletter as a draft campaign.

## 09. Review and Error Handling

The campaign is created as a draft in Campaign Monitor so the team can review it before sending. If Campaign Monitor returns an error, the scenario skips that run instead of stopping with an error.

## 10. Outcome

The scenario allows editors to prepare newsletter content in Google Sheets and generate a corresponding Campaign Monitor draft without manually copying each content block into the email editor. The team can review the generated draft in Campaign Monitor before sending it.

---

# Automation of Shopify Orders to Google Sheets for Dropshipping E-commerce Store

> The primary goal of this automation is to streamline the process of managing Shopify orders by automatically distributing them to the appropriate fulfillment sheets.

Section: Make Automations

Page: https://mburhan.com/case/make-automation-of-shopify-orders-to-google

## Project Overview

This Make automation streamlines Shopify order management for a dropshipping e-commerce store. It records incoming orders, identifies the relevant products, and distributes order information to the appropriate Google Sheets fulfillment sheets based on supplier requirements.

## How It Works

### 1. Shopify Order Tracking

When a new order is created in Shopify, the automation adds the order to a Make Data Store for tracking.

### 2. Product Identification

The workflow checks product IDs against a Google Sheets database to determine which supplier's fulfillment sheet should receive the order.

### 3. Master Sheet Integration

A master sheet consolidates order information. Changes made to the master sheet are reflected in the respective Google Sheets to maintain consistency.

### 4. Supplier-Based Order Distribution

Order details are routed to the appropriate fulfillment sheets so that each supplier receives the relevant order information.

Image (https://mburhan.com/case-content/make-portfolio/image1.png)

Image (https://mburhan.com/case-content/make-portfolio/image2.png)

## Workflow Architecture

A master sheet serves as the central location for consolidating and managing order information.

Image (https://mburhan.com/uploads/59add0f62757485d25be3b4c.png)

## Tools and Integrations

- **Make:** Automates the workflow and coordinates data between applications.
- **Shopify:** Provides order and product information.
- **Google Sheets:** Stores product IDs, consolidates order data, and supports supplier-specific fulfillment tracking.

## Outcome

The automation helps organize Shopify orders, distribute them according to supplier requirements, and keep order information consistent across the relevant Google Sheets.

---

# Daily Slack Updates Make Scenario

> The automation is designed to send daily updates to Slack. The data in Google Sheets is updated daily, and the KPI data is sent to Slack every day using a Make scenario.

Section: Make Automations

Page: https://mburhan.com/case/make-daily-slack-updates-make-scenario

## Project Overview

This Make scenario sends daily KPI updates to Slack using data from Google Sheets. The spreadsheet data is updated daily, and the scenario delivers the KPI information to Slack.

## How It Works

### 1. Google Sheets Data

The scenario uses data from Google Sheets as the source for daily KPI updates.

### 2. Router

A Router splits the workflow into two separate branches.

### 3. Retrieve KPI Values

Each branch uses a Google Sheets module to retrieve the relevant range values.

### 4. Send Slack Updates

Each branch sends a message to Slack with the corresponding KPI information.

Image: Screenshot of working automation (https://mburhan.com/case-content/make-portfolio/image4.png)

## Workflow Architecture

Image (https://mburhan.com/uploads/e09140e57754862437b0a579.png)

The workflow contains two branches, each connecting a Google Sheets module to a Slack message module.

## Tools and Integrations

- **Make:** Connects the modules and manages the workflow.
- **Google Sheets:** Provides the KPI data.
- **Slack:** Receives the daily updates.

## Outcome

The scenario automates the delivery of daily KPI updates from Google Sheets to Slack, reducing the need to share these updates manually.

---

# Automation of ClickUp and Google Sheets

> This Make scenario is implemented whenever a task gets completed in ClickUp.

Section: Make Automations

Page: https://mburhan.com/case/make-automation-of-clickup-and-google-sheets

## Project Overview

This Make automation connects ClickUp with Google Sheets to transfer completed task details into the appropriate spreadsheet. When a task is completed in ClickUp, the scenario processes its information and uses custom fields to determine which Google Sheets file should receive the data.

## The Business Need

Task information needs to be recorded in the relevant Google Sheets file when work is completed in ClickUp. This scenario automates that transfer and routes the data according to the task's custom fields.

## The Solution

The Make scenario uses a custom webhook, variable configuration, and a router to direct information into Google Sheets.

- **Webhooks:** Receives data through a custom webhook.
- **Tools:** Sets multiple variables used during processing.
- **Router:** Splits the workflow into two branches.
- **Google Sheets:** Each branch adds a row to a spreadsheet.

## How It Works

### 1. Receive the Webhook

The workflow starts when the custom webhook receives the task information.

### 2. Set Variables

The Tools module sets multiple variables that are used in the subsequent workflow steps.

### 3. Route the Data

The Router divides the workflow into two branches. The routing logic uses the task's custom fields to determine the appropriate destination.

### 4. Add a Row to Google Sheets

Each branch connects to a Google Sheets module configured to add a row to its respective spreadsheet.

Image: Screenshot of working automation in make.com (https://mburhan.com/case-content/make-portfolio/image5.png)

## Workflow Architecture

Image (https://mburhan.com/uploads/b82ec5b29b4f30420d70ccdc.png)

The router splits the workflow into two Google Sheets branches, allowing data to be directed to the relevant destination.

## Tools and Integrations

- **Make:** Connects the workflow modules and manages routing.
- **ClickUp:** Provides the completed task information.
- **Google Sheets:** Receives task details as new spreadsheet rows.

## Outcome

The scenario automates the transfer of completed task information into Google Sheets and routes the data according to custom fields, reducing the need to enter the same information manually.

---

# Integration of Shopify and ClickUp for Managing Refunded Orders

> This scenario is built so that whenever there is a refunded order in Shopify, the order details are added to ClickUp as tasks.

Section: Make Automations

Page: https://mburhan.com/case/make-integration-of-shopify-and-clickup-for

## Project Overview

This Make automation connects Shopify with ClickUp to help manage refunded orders. When an order is refunded in Shopify, the scenario retrieves the order details and uses them in the ClickUp task-management workflow.

The integration brings refunded-order information into ClickUp, making it easier for the team to manage refund-related tasks in one place.

## The Business Need

Refunded orders need to be identified and their details made available for follow-up. Without an automated connection between Shopify and ClickUp, the team may need to transfer order information manually when managing refunded orders.

## The Solution

The Make scenario connects Shopify and ClickUp through an automated workflow.

- **Shopify trigger:** Starts the scenario when a new event is detected.
- **Get an order:** Retrieves the relevant order details from Shopify.
- **Data Store:** Searches for a matching record as part of the workflow.
- **ClickUp:** Updates a task with custom fields using the available information.
- **Tools:** Includes a sleep step before the final Data Store action.
- **Data Store cleanup:** Deletes a record at the end of the scenario.

## How It Works

### 1. Shopify Event

The workflow begins with a Shopify event that triggers the scenario.

### 2. Retrieve Order Information

The Shopify module retrieves the order details needed for the next steps.

### 3. Search the Data Store

The scenario searches the Data Store for a relevant record before continuing.

### 4. Update ClickUp

The ClickUp module edits a task using custom fields, connecting the order information with the task-management process.

### 5. Execute Follow-up Actions

A Tools sleep step runs before the final Data Store module deletes a record.

Image: Screenshot of working automation from make.com (https://mburhan.com/case-content/make-portfolio/image6.png)

## Workflow Architecture

Image (https://mburhan.com/uploads/14f1b40ba7396f7617356646.png)

## Tools and Integrations

- **Make:** Connects the applications and runs the scenario.
- **Shopify:** Provides the order event and order details.
- **ClickUp:** Manages tasks using custom fields.
- **Data Store:** Supports record searching and deletion.

## Outcome

The scenario connects Shopify order events with ClickUp task updates and Data Store operations. Its purpose is to streamline the handling of refunded-order information by bringing these steps into one automated workflow.

---

# Fulfilled Order Integration with ClickUp

> This Make scenario is implemented so that whenever an order is fulfilled in Shopify, the order details are added to ClickUp.

Section: Make Automations

Page: https://mburhan.com/case/make-fulfilled-order-integration-with-clickup

## Project Overview

This Make automation connects Shopify with ClickUp, Google Sheets, and Slack to process fulfilled orders and update the relevant records.

When an order is fulfilled in Shopify, the scenario retrieves the order details, searches for a matching record in the Data Store, adds a row to Google Sheets, and updates a ClickUp task with custom fields. The workflow also includes Data Store and Slack actions after the ClickUp update.

## The Solution

The Make scenario automates the order-fulfilment process by connecting the relevant applications in a single workflow.

- **Shopify:** Triggers the scenario when a new order is fulfilled and retrieves the order details.
- **Data Store:** Searches for a matching record using the available order information.
- **Google Sheets:** Adds a row containing the order information.
- **ClickUp:** Updates a task with custom fields using the processed order details.
- **Data Store:** Performs a follow-up action to delete a record.
- **Slack:** Creates a message as part of the workflow.

## How It Works

### 1. Shopify Order Trigger

The workflow starts when Shopify detects a newly fulfilled order. This event initiates the scenario and provides the order information for subsequent steps.

### 2. Retrieve Order Details

The scenario retrieves the corresponding order details from Shopify so they can be used by the following modules.

### 3. Search the Data Store

The workflow searches the Data Store for a record associated with the order. This step helps the scenario use the available stored information before continuing.

### 4. Add a Row to Google Sheets

The order information is added to Google Sheets, creating a record of the fulfilled order in the spreadsheet.

### 5. Update the ClickUp Task

The scenario updates a ClickUp task using custom fields. This connects the order-processing workflow with task management.

### 6. Perform Follow-up Actions

After the ClickUp update, the scenario branches into two actions: deleting a record from the Data Store and creating a message in Slack.

Image: Screenshot of working automation of make.com (https://mburhan.com/case-content/make-portfolio/image7.png)

## Workflow Architecture

Image (https://mburhan.com/uploads/7c20da5d1263d8b69854b156.png)

## Tools and Integrations

- **Make:** Connects the applications and orchestrates the automation.
- **Shopify:** Supplies the order event and order details.
- **Data Store:** Searches and deletes records.
- **Google Sheets:** Stores order information in a spreadsheet.
- **ClickUp:** Updates tasks with custom fields.
- **Slack:** Creates a message through the workflow.

## Outcome

The scenario connects Shopify order fulfilment with spreadsheet recordkeeping, ClickUp task updates, Data Store operations, and Slack messaging. It brings these actions together in one Make automation, reducing the need to perform each connected step manually.

---

# Automating IG RSS Feed to Pinterest Pin Creation

> This automation is implemented to create a Pinterest pin whenever RSS data is received.

Section: Make Automations

Page: https://mburhan.com/case/make-automating-ig-rss-feed-to-pinterest

## Automating Instagram RSS Feed to Pinterest Pin Creation

Automatically create Pinterest pins whenever new RSS feed data is received, using Make and text parsing.

## Project Overview

This Make automation creates a Pinterest pin whenever RSS data is received. Multiple text parsers are used to extract and format the relevant information before creating the pin.

## The Workflow

### 1. Receive RSS Data

The automation starts when RSS feed data is received.

### 2. Extract and Parse Text

Multiple text parsers process the incoming data to ensure the required information is extracted and placed in the relevant format.

### 3. Prepare Pinterest Content

The parsed data is formatted appropriately for Pinterest pin creation.

### 4. Create a Pinterest Pin

The automation uses the processed RSS information to create a Pinterest pin.

Image (https://mburhan.com/uploads/580dc3610b6b1db9e336a56e.png)

## Platforms Used

- **Make:** Runs the automation and processes the incoming data.
- **Pinterest:** Receives the created pins.

Image: Screenshot of working automation in make.com (https://mburhan.com/case-content/make-portfolio/image8.png)

## Outcome

The automation streamlines RSS-to-Pinterest content creation, reduces manual effort, and helps keep Pinterest updated with content from the RSS feed.

---

# Integration of RB2B with Go High Level and Beehiv

> RB2B is a platform that collects website visitor profiles.

Section: Make Automations

Page: https://mburhan.com/case/make-integration-of-rb2b-with-go-high

## Project Overview

This automation connects RB2B, GoHighLevel, and Beehiiv through Make. When RB2B creates a website visitor profile, the profile is added to GoHighLevel as a contact, a deal is created for that contact, and the associated email is added to Beehiiv as a subscriber.

## The Workflow

### 1. Website Visitor Profile

RB2B collects website visitor profiles and triggers the automation when a new profile is created.

### 2. Create a Contact in GoHighLevel

The visitor profile is added to GoHighLevel as a contact.

### 3. Create a Deal

A deal is also created in GoHighLevel for the new contact.

### 4. Add a Beehiiv Subscriber

The associated email address is added to Beehiiv as a subscriber.

Image: Screenshot of working automation in make.com (https://mburhan.com/case-content/make-portfolio/image9.png)

## Platforms Used

- **Make:** Connects the platforms and automates the workflow.
- **RB2B:** Collects website visitor profiles.
- **GoHighLevel:** Stores the contact and its associated deal.
- **Beehiiv:** Receives the email address as a subscriber.

## Outcome

The workflow automates the transfer of visitor profile information into GoHighLevel and adds the associated email address to Beehiiv, connecting contact and deal creation with subscriber addition.

---

# Integration of Go High Level with Beehiv

> This scenario is implemented so that whenever the status of an opportunity is changed in Go High Level, the associated email is added to Beehiv as a subscriber.

Section: Make Automations

Page: https://mburhan.com/case/make-integration-of-go-high-level-with

## Project Overview

This automation connects GoHighLevel and Beehiiv through Make. When an opportunity’s status changes in GoHighLevel, the associated email address is sent to Beehiiv and added as a subscriber.

## The Solution

The Make scenario automates the transfer of contact email information between GoHighLevel and Beehiiv when an opportunity status changes.

### How It Works

1. **Opportunity Status Changes:** The scenario responds when an opportunity’s status is changed in GoHighLevel.
2. **Process the Contact Information:** Make handles the information associated with the opportunity.
3. **Add the Subscriber to Beehiiv:** The associated email address is added to Beehiiv as a subscriber.

Image: Screenshot of working automation from make.com (https://mburhan.com/case-content/make-portfolio/image10.png)

## Platforms Used

- **Make:** Connects the two platforms and runs the automation.
- **GoHighLevel:** Provides the opportunity status change that triggers the scenario.
- **Beehiiv:** Receives the associated email address as a subscriber.

## Outcome

The integration automates adding email addresses to Beehiiv following opportunity status changes in GoHighLevel, reducing the need to transfer subscriber information manually

---

# AI-Powered Shopify Abandoned Cart Recovery System

> An always-on automation that detects abandoned Shopify carts and sends personalized, AI-written recovery emails.

Section: n8n Automations, Make Automations, AI Agents, AI Agents for Ecommerce

Page: https://mburhan.com/case/ecom-agent-ai-powered-shopify-abandoned-cart-recovery

## 01. The Problem: Abandoned Carts Were Leaving Revenue on the Table

Before automation, abandoned carts were often handled manually or received no follow-up at all.

- Teams had to check Shopify manually for abandoned checkouts.
- Writing reminder emails took time and effort.
- Follow-ups were inconsistent, and many carts were never contacted.
- Generic emails lacked personalization.
- Delayed reminders reduced the chance of customers completing their purchases.

### The Cost of Manual Follow-Ups

For stores handling 40–60 abandoned carts per day:

- Each follow-up took approximately 5–7 minutes.
- Manual work could consume 3–5 hours daily.
- Some stores followed up only once a day or skipped follow-ups entirely.

Without timely reminders, potential sales were lost.

## 02. Results After Automation

The automated workflow ensures abandoned checkouts receive timely, personalized recovery emails with minimal human intervention.

- **100% recovery-attempt coverage:** Every detected abandoned cart receives a recovery attempt.
- **90–95% less manual work:** Repetitive follow-up tasks are automated.
- **Faster communication:** Recovery emails are sent within the configured time window.
- **AI personalization:** Each email is generated to provide a relevant, friendly reminder.

### Time Savings

| Metric | Before Automation | After Automation |
| --- | --- | --- |
| Follow-up process | Manual | Automated |
| Time per cart | Approximately 6 minutes | Minimal manual effort |
| Daily workload | Around 3–5 hours | Near-zero routine effort |
| Monthly time savings | — | Approximately 100–120 hours |

### Potential Revenue Impact

Using a conservative example of 50 abandoned carts per day, a $50 average cart value, and a 5–8% recovery rate:

- **Potential recovered sales:** $125–$200 per day.
- **Potential recovered sales:** Approximately $3,750–$6,000 per 30-day month.

These figures are illustrative estimates, not guaranteed results. Actual performance depends on store traffic, customer behavior, email deliverability, and conversion rates.

## 03. The Solution: AI-Powered Abandoned Cart Recovery

The system works as an always-on sales assistant that follows up with customers automatically.

It:

- Detects abandoned Shopify checkouts.
- Waits for a configured period before sending a reminder.
- Verifies that the checkout is still abandoned and has not been completed.
- Uses AI to generate a personalized recovery email.
- Sends the email automatically through Gmail or a configured email service.

The workflow operates in the background, reducing repetitive work while keeping follow-ups consistent.

## 04. How the Automation Works

The workflow connects Shopify, an automation platform, AI, and email delivery.

1. **Abandoned Checkout Detection:** Shopify provides abandoned checkout data.
2. **Wait and Verify:** The automation waits and checks whether the checkout remains abandoned.
3. **AI Email Generation:** OpenAI generates a friendly, personalized recovery message.
4. **Email Delivery:** Gmail or the configured email service sends the message to the customer.
5. **Scheduled Execution:** The workflow runs automatically according to its configured schedule.

## Workflow:

Image (https://mburhan.com/uploads/b7ebb79125925b2fb319880b.png)

No routine manual follow-up is required once the workflow is configured and activated.

## 05. Business Value

### Recover Potential Revenue

Re-engages customers who leave products in their carts and creates another opportunity to complete a purchase.

### Reduce Manual Work

Eliminates repetitive checkout monitoring and email-writing tasks.

### Improve Customer Experience

Delivers timely reminders with more relevant, personalized messaging.

### Ensure Consistent Follow-Ups

Provides a recovery attempt for every detected abandoned checkout that meets the workflow conditions.

### Scale With Store Growth

Handles increasing checkout volumes without requiring a proportional increase in manual effort.

## 06. How to Replicate the System

Use the provided workflow blueprint to configure the automation in Make.com.

### Step 1: Import the Blueprint

1. Open the attached JSON file: **Shopify Abandoned Checkout Recovery with Order Verification (1).json**.
2. Select and copy the complete JSON content.
3. Log in to Make.com and open **Scenarios**.
4. Create a new scenario and choose the blueprint import option.
5. Import the JSON, save the scenario, and name it **Shopify Abandoned Checkout Recovery with Order Verification**.

### Step 2: Configure Shopify

- Connect your Shopify account.
- Confirm that the workflow retrieves abandoned checkouts.
- Verify that the checkout status and required customer fields are mapped correctly.

### Step 3: Configure the Wait and Verification Logic

- Review the delay before sending the recovery email.
- Verify that the checkout has not been completed.
- Prevent duplicate or unnecessary recovery emails.

### Step 4: Configure OpenAI

- Add your OpenAI API key.
- Confirm that the AI generates a relevant, friendly recovery email.
- Check that the email body follows your desired format and tone.

### Step 5: Configure Email Delivery

- Reconnect Gmail or your SMTP email service.
- Map the customer's email address dynamically.
- Set the email subject to **You left something behind**.
- Verify the recipient, subject, and generated email body.

### Step 6: Test and Activate

1. Run the scenario once.
2. Verify that abandoned checkout data is retrieved.
3. Confirm that the checkout verification works.
4. Check that the AI-generated email is correct.
5. Confirm that the recovery email is delivered successfully.
6. Activate the scenario and configure an appropriate schedule, such as every 15–60 minutes.

**Important:** The actual schedule, delay, and verification rules should match your store's requirements and the imported workflow configuration.

## 07. Final Outcome

The AI-Powered Shopify Abandoned Cart Recovery System transforms abandoned checkouts into automated follow-up opportunities.

By combining Shopify checkout data, workflow automation, AI-generated emails, and automated delivery, the system helps businesses:

- Follow up consistently with abandoned carts.
- Reduce repetitive manual work.
- Deliver timely, personalized reminders.
- Create additional opportunities to recover lost sales.
- Scale their recovery process as the business grows.

**The result:** A reliable, always-on abandoned cart recovery workflow that supports revenue recovery without increasing routine workload.
