MODULE 1 Conversion Tracking & Attribution Track

Meta Conversion Tracking & Automation Laboratory

A complete, hands-on student laboratory based on a real Upwork client project.

Covers Meta Pixel, Conversions API, n8n, Zapier, Typeform, Calendly, Google Sheets, and Stripe. 20 implementation layers. Platform-independent automation architecture.

End of raw client brief. Everything above is the client's exact language. We have not changed a single word.

A professional freelancer does not simply execute a client brief line by line. They read the brief, identify what the client actually needs, separate it from the specific words the client used, and flag anything that requires verification or discussion. Below, we analyze each major requirement.

Requirement 1: "Meta Pixel Audit"

Requirement 2: "Add Meta Pixel to Calendly"

Requirement 3: "Fire Meta 'Schedule' offline conversion"

Requirement 4: "Call attended (marked in Calendly)"

Requirement 5: "Lead marked 'Qualified' in Google Sheet"

Requirement 6: "Configure Custom Conversions in Meta Events Manager"

Requirement 7: "Zapier" as the automation platform

Current State

The client runs Meta ads that drive traffic to a B2B marketing agency website. Visitors fill out a Typeform, which fires a Lead event to Meta. Meta's ad delivery algorithm receives this single signal and optimizes for it — finding more people likely to fill out a form.

The Information Gap

After the form submission, the client's funnel continues: qualified leads book Calendly calls, attend those calls, get evaluated, and some sign contracts worth €1,400–€1,700/month via Stripe. Meta knows nothing about any of this. As far as Meta's algorithm is concerned, every form submission is equally valuable. A tire-kicker who submits the form and never books a call looks identical to a client who signs a €1,700/month contract.

Desired State

The client wants Meta to receive five signals along the funnel, each representing a progressively more valuable business action:

With all five signals, Meta can learn which ad clicks ultimately lead to paying clients — and optimize ad delivery to find more people like them.

Business Objectives

Improve Meta ad performance by giving the algorithm richer downstream conversion signals. Reduce cost per acquisition by optimizing for qualified leads and purchases rather than form fills. Gain visibility into the full funnel from ad click to signed contract.

Tracking Objectives

Track five conversion events: Lead (form submission), Schedule (Calendly booking), CallAttended (prospect showed up), QualifiedLead (manually assessed), Purchase (Stripe payment with value). Each event must carry identity data sufficient for Meta to match it back to the original ad click.

Automation Objectives

Automate the transmission of conversion events to Meta whenever a business action occurs. Minimize manual work — the team should only need to mark attendance and qualification in a spreadsheet; everything else should happen automatically.

Meta Objectives

All five events visible in Meta Events Manager. Events usable for campaign optimization in Ads Manager. Event Match Quality high enough for reliable attribution.

Reporting & Documentation Objectives

A Google Sheet tracking every lead through the funnel. A Loom walkthrough video. Written documentation with screenshots. The client must be able to troubleshoot independently after handover.

Commercial Constraints

The Funnel

The Five Handshakes

Before implementation, a professional reviews each requirement against technical reality.

Primary Automation Platform: n8n

n8n is a workflow automation tool that you can self-host for free. Unlike Zapier (which abstracts the HTTP layer), n8n exposes every HTTP request, every JSON payload, and every transformation. This makes it the ideal laboratory for understanding what actually happens when you "send an event to Meta."

Tool Inventory

Installation: n8n Self-Hosted

Choose one method:

Option A: npm (simplest for learning)

npx n8n

This downloads and starts n8n. Access the UI at http://localhost:5678. Your workflows are saved locally.

Option B: Docker (recommended for persistence)

docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  docker.n8n.io/n8nio/n8n

Access at http://localhost:5678. The -v flag persists your data.

Option C: n8n Cloud Trial

Go to n8n.io → Start Free → Create account. 14-day trial, no credit card. Webhooks work without tunneling.

Set up and understand the Meta infrastructure that receives conversion events.

Every conversion event in this laboratory is ultimately sent to Meta. Before building anything, you must understand what Meta's tracking infrastructure is, how it works, and where to verify that events arrive.

BROWSER (visitor's device)          SERVER (your automation)
         │                                    │
    Meta Pixel JS                        HTTP POST
    (fbevents.js)                   (Conversions API)
         │                                    │
         └──────────┐          ┌──────────────┘
                    ▼          ▼
              ┌─────────────────────┐
              │   META DATASET      │
              │   (one Pixel ID)    │
              │   (two inputs)      │
              └─────────────────────┘
                        │
                        ▼
              ┌─────────────────────┐
              │   EVENTS MANAGER    │
              │   (view, test,      │
              │    verify events)   │
              └─────────────────────┘

Meta Business Suite / Business Manager: The administrative container for all business assets — ad accounts, Pages, Pixels/Datasets, catalogs, users. Everything lives inside this container.

Dataset (formerly "Pixel"): Meta now uses the term "Dataset" for the unified tracking asset. A Dataset has one ID (the Pixel ID) and accepts events from two sources: browser-side (Meta Pixel JavaScript) and server-side (Conversions API). Both paths feed the same Dataset.

Meta Pixel: A JavaScript snippet (fbevents.js) that runs in the visitor's browser. It sends events to Meta when the visitor performs actions on your website. It has access to browser cookies (_fbp, _fbc) that help Meta identify the visitor.

Conversions API (CAPI): A server-to-server HTTP API. Your server sends an HTTP POST request to https://graph.facebook.com/v21.0/{PIXEL_ID}/events with event data. No browser is involved. The API version may change — always verify the current version at developers.facebook.com/docs/graph-api/changelog.

Events Manager: The Meta dashboard where you see incoming events, test events, verify event parameters, check Event Match Quality, and diagnose problems. This is your primary verification tool throughout the lab.

Test Events: A feature in Events Manager that lets you send events with a test_event_code. Test events appear in a separate tab and do not affect your ad delivery or reporting. Use this for all laboratory work.

• A personal Facebook account
• Access to Meta Business Suite (business.facebook.com)

1. Access Meta Business Suite. Go to business.facebook.com. If you don't have a Business account, create one — it's free. You'll need a Facebook Page (create a test one if needed).
2. Navigate to Events Manager. In the left sidebar, find "Events Manager" (or go to facebook.com/events_manager2 directly). This is where all event data flows.
3. Locate or create a Dataset. In Events Manager, look at "Data Sources" in the left panel. If you have an existing Pixel/Dataset, click it. If not, click "Connect Data Sources" → "Web" → name it (e.g., "Lab Test Dataset") → "Create." Note the Pixel ID — a numeric string like 123456789012345. You will use this ID in every CAPI request.
4. Generate an access token. In Events Manager, select your Dataset → Settings → scroll to "Conversions API" section → "Generate access token." Click through the prompts. Copy this token and store it securely — you will need it for every CAPI HTTP request. This token does not expire but can be revoked.
5. Find the Test Events tab. In Events Manager, select your Dataset → "Test Events" tab. Note the Test Event Code displayed (e.g., TEST12345). Any CAPI request that includes this code in the payload will appear here without affecting production data.
6. Record your credentials. Save these three values — you will need them throughout the lab:

PIXEL_ID       = ___________________________
ACCESS_TOKEN   = ___________________________
TEST_EVENT_CODE = ___________________________

No data mapping in this layer — we are setting up infrastructure, not sending events.

No trigger in this layer.

No workflow in this layer.

All steps are manual in this layer — this is one-time setup.

No event transmission in this layer.

No event sent yet.

Verify: Dataset is active (green dot in Events Manager). Access token is generated. Test Event Code is visible.

Send a manual test event using curl to verify your credentials work:

curl -X POST \
  "https://graph.facebook.com/v21.0/YOUR_PIXEL_ID/events" \
  -H "Content-Type: application/json" \
  -d '{
    "data": [{
      "event_name": "PageView",
      "event_time": CURRENT_UNIX_TIMESTAMP,
      "action_source": "website",
      "user_data": {
        "client_ip_address": "1.2.3.4",
        "client_user_agent": "Mozilla/5.0 Test"
      }
    }],
    "test_event_code": "YOUR_TEST_EVENT_CODE",
    "access_token": "YOUR_ACCESS_TOKEN"
  }'

Replace YOUR_PIXEL_ID, CURRENT_UNIX_TIMESTAMP (get it: date +%s in terminal, or use an online converter), YOUR_TEST_EVENT_CODE, and YOUR_ACCESS_TOKEN.

Go to Events Manager → Test Events tab. You should see a PageView event appear within 30 seconds.

A PageView event in the Test Events tab with "Conversions API" as the source. The response from curl should be:

{"events_received": 1, "messages": [], "fbtrace_id": "..."}

• Pixel ID recorded
• Access token generated and stored
• Test Event Code noted
• Manual curl test event visible in Events Manager → Test Events
• You can explain: "The Pixel ID identifies my Dataset. The Pixel JavaScript sends browser events. The Conversions API sends server events. Both feed the same Dataset."

Create a free test website and install the Meta Pixel to track browser-side page views.

The client's real site is on Shopify, but for this laboratory we use a free static website (GitHub Pages). This lets you understand Pixel installation at the HTML level — without Shopify's abstraction. In production, Shopify installs the Pixel via its Meta channel app, but the underlying mechanism is the same: a JavaScript snippet in the page's <head>.

VISITOR (browser)
    │
    ▼
┌────────────────────────────┐
│  YOUR WEBSITE              │
│  (GitHub Pages)            │
│                            │
│  <head>                    │
│    Meta Pixel base code    │
│    fbq('init', PIXEL_ID)  │
│    fbq('track','PageView')│
│  </head>                   │
└────────────────────────────┘
    │
    │  fbevents.js fires
    │  HTTP request to Meta
    ▼
┌────────────────────────────┐
│  META EVENTS MANAGER       │
│  → PageView received       │
│  → Source: Pixel (browser) │
└────────────────────────────┘

Meta Pixel base code: A JavaScript snippet that loads fbevents.js, initializes with your Pixel ID, and fires a PageView event on every page load. This is the foundation of browser-side tracking.

GitHub Pages: Free static website hosting from GitHub. You push HTML files to a repository and GitHub serves them at https://yourusername.github.io/reponame/. You have full control over the HTML, including the <head> section where the Pixel goes.

Why not Shopify for the lab: Shopify requires a paid plan ($39/month+). The Meta channel on Shopify installs the Pixel automatically — useful for a real client, but it hides the mechanism. You need to understand what the Pixel code actually is before relying on a platform to install it for you.

• Layer 1 complete (Pixel ID available)
• A GitHub account (free)
• Git installed locally, or use GitHub's web editor

1. Create a GitHub repository. Go to github.com → New repository → Name it meta-capi-lab → Public → check "Add a README file" → Create.
2. Enable GitHub Pages. In the repository, go to Settings → Pages → Source: "Deploy from a branch" → Branch: main, folder: / (root) → Save. Your site will be live at https://YOURUSERNAME.github.io/meta-capi-lab/ within a minute.
3. Create index.html. In the repository, click "Add file" → "Create new file" → name it index.html → paste the following:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>ScaleUp Partner — Discovery Call</title>

  <!-- META PIXEL BASE CODE -->
  <script>
    !function(f,b,e,v,n,t,s)
    {if(f.fbq)return;n=f.fbq=function(){n.callMethod?
    n.callMethod.apply(n,arguments):n.queue.push(arguments)};
    if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version='2.0';
    n.queue=[];t=b.createElement(e);t.async=!0;
    t.src=v;s=b.getElementsByTagName(e)[0];
    s.parentNode.insertBefore(t,s)}(window, document,'script',
    'https://connect.facebook.net/en_US/fbevents.js');
    fbq('init', 'YOUR_PIXEL_ID');
    fbq('track', 'PageView');
  </script>
  <noscript><img height="1" width="1" style="display:none"
    src="https://www.facebook.com/tr?id=YOUR_PIXEL_ID&ev=PageView&noscript=1"
  /></noscript>
  <!-- END META PIXEL BASE CODE -->

  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body { font-family: system-ui, sans-serif; background: #f8f9fa;
           color: #1a1a2e; line-height: 1.6; }
    .hero { max-width: 640px; margin: 3rem auto; padding: 2rem;
            background: #fff; border-radius: 12px;
            box-shadow: 0 2px 8px rgba(0,0,0,0.08); }
    h1 { font-size: 1.6rem; margin-bottom: 0.5rem; }
    p { margin: 0.5rem 0; color: #555; }
    .cta { display: inline-block; margin-top: 1rem; padding: 0.8rem 2rem;
           background: #1565E6; color: #fff; text-decoration: none;
           border-radius: 8px; font-weight: 600; }
    #typeform-container { margin-top: 2rem; min-height: 500px; }
  </style>
</head>
<body>
  <div class="hero">
    <h1>Get More Qualified Leads for Your Business</h1>
    <p>ScaleUp Partner helps B2B companies generate qualified enquiries
       through Meta advertising. Fill out the form below to see if we're
       a good fit.</p>
    <div id="typeform-container">
      <!-- Typeform will be embedded here in Layer 3 -->
      <p style="color:#999; text-align:center; padding:3rem;">
        [Typeform embed placeholder — completed in Layer 3]
      </p>
    </div>
  </div>
</body>
</html>

4. Replace YOUR_PIXEL_ID in both places (the fbq('init',...) call and the <noscript> image) with your actual Pixel ID from Layer 1.
5. Commit the file. Scroll down → "Commit new file."
6. Wait ~60 seconds for GitHub Pages to deploy, then visit your site URL.
7. Install Meta Pixel Helper. In Chrome, install the "Meta Pixel Helper" extension from the Chrome Web Store. It shows a badge on pages where the Pixel is detected.
8. Visit your site. Open https://YOURUSERNAME.github.io/meta-capi-lab/. The Pixel Helper should show a green badge with "1" (one PageView event detected).

Open Events Manager → Overview or Test Events. Within a few minutes, you should see a PageView event from your Pixel, with "Pixel" as the connection method.

• Meta Pixel Helper shows green badge on your site
• PageView event appears in Events Manager
• Source is "Pixel" (browser-side), not "Conversions API"

A live website with Meta Pixel installed. Every visit generates a PageView event visible in Events Manager.

• Website live on GitHub Pages
• Meta Pixel base code installed in <head>
• PageView event verified in Events Manager
• You can explain: "When a visitor loads my page, the Pixel JavaScript fires a PageView event to Meta via the visitor's browser."

Create a qualifying Typeform and embed it in your test website. Understand the boundary between the website and the embedded form.

The client's funnel starts with a Typeform that captures lead information. You need to understand exactly how an embedded Typeform relates to the parent page — because this boundary determines whether the Meta Pixel can detect form submissions.

┌─────────────────────────────────────────────┐
│  YOUR WEBSITE  (GitHub Pages)               │
│  ┌─ Meta Pixel (runs here) ──────────────┐  │
│  │  Can see: page loads, clicks,         │  │
│  │  URL changes on THIS domain           │  │
│  └───────────────────────────────────────┘  │
│                                             │
│  ┌─ TYPEFORM IFRAME ─────────────────────┐  │
│  │  ╔═══════════════════════════════════╗ │  │
│  │  ║  Typeform renders HERE            ║ │  │
│  │  ║  Separate origin (typeform.com)   ║ │  │
│  │  ║  Pixel CANNOT see inside this     ║ │  │
│  │  ╚═══════════════════════════════════╝ │  │
│  └───────────────────────────────────────┘  │
└─────────────────────────────────────────────┘

iframe isolation: When Typeform is embedded on your page, it renders inside an <iframe>. The iframe's origin is typeform.com, not your domain. Due to browser same-origin policy, your Meta Pixel JavaScript cannot detect events inside the iframe — it cannot see form field inputs, button clicks, or submission. This is a fundamental browser security boundary.

Typeform embed SDK: Typeform provides an embed library (@typeform/embed) that offers callbacks — including onSubmit — that fire on the parent page when the user completes the form inside the iframe. This is the bridge that lets your page know something happened inside the Typeform.

• Layer 2 complete (website live with Pixel)
• A Typeform account (free plan works)

1. Create a Typeform account at typeform.com if you don't have one.
2. Create a new form. Click "Create form" → Start from scratch. Name it "ScaleUp Partner — Discovery Application."
3. Add these fields (matching the client's qualifying questions):
   Field 1: Short Text — "What is your full name?" (Required)
   Field 2: Email — "What is your email address?" (Required)
   Field 3: Phone Number — "What is your phone number?" (Required)
   Field 4: Dropdown — "What country are you based in?" (Add 5-10 countries)
   Field 5: Short Text — "What does your business do?"
   Field 6: Multiple Choice — "What is your monthly marketing budget?" (Options: Under €1,000 / €1,000–€5,000 / €5,000–€10,000 / Over €10,000)
   Field 7: Long Text — "What is your biggest marketing challenge right now?"
4. Publish the form. Click "Publish." Note your form ID from the URL — it looks like https://form.typeform.com/to/AbCdEf. The AbCdEf part is your form ID.
5. Get the embed code. On the Publish page, click "Embed" → "Inline" → copy the code. It will look something like:

<div data-tf-widget="AbCdEf" data-tf-inline-on-mobile
     data-tf-medium="snippet" style="width:100%;height:500px;">
</div>
<script src="//embed.typeform.com/next/embed.js"></script>

6. Update your index.html. Replace the placeholder inside #typeform-container with the embed code from Typeform. Your updated container should look like:

<div id="typeform-container">
  <div data-tf-widget="AbCdEf" data-tf-inline-on-mobile
       data-tf-medium="snippet"
       data-tf-on-submit="typeformSubmitted"
       style="width:100%;height:500px;">
  </div>
  <script src="//embed.typeform.com/next/embed.js"></script>
</div>

Note the addition of data-tf-on-submit="typeformSubmitted" — this is the callback we'll use in Layer 4 to detect submission. Add it now.

7. Commit and push. Wait for GitHub Pages to redeploy (~60 seconds).
8. Test the embed. Visit your site. The Typeform should render inline on the page. Fill it out with test data to verify it works.

Submit the form with test data. After submission, the Typeform should show a "Thank you" screen (or redirect, depending on settings). The Meta Pixel Helper should still show the PageView — but no Lead event yet. That comes in Layer 4.

• Typeform renders inline on the website
• All 7 fields are present and functional
• Form submission works (test response appears in Typeform's Responses tab)
• No Lead event fires yet (this is expected — we haven't built that yet)

• Typeform embedded and functional on the test website
• data-tf-on-submit="typeformSubmitted" attribute is present (for Layer 4)
• You can explain: "The Typeform renders inside an iframe. My Pixel cannot see inside it. I need the Typeform embed SDK's onSubmit callback to detect when the form is submitted."

Fire a Meta Lead event when a visitor submits the Typeform. This is Handshake #1.

This is the client's existing tracking mechanism — the only event Meta currently receives. We implement it properly so we understand the baseline before adding the four remaining handshakes.

Visitor submits Typeform
    │
    ▼ (Typeform embed SDK fires onSubmit callback)
    │
    ▼ (callback runs on PARENT page, where Pixel lives)
    │
    fbq('track', 'Lead')
    │
    ▼ (Pixel sends Lead event to Meta via browser)
    │
META EVENTS MANAGER → Lead received (source: Pixel)

The onSubmit callback bridge: When the Typeform embed SDK detects a successful submission inside the iframe, it calls the JavaScript function named in data-tf-on-submit on the parent page. This is the bridge across the iframe boundary. The callback receives the response ID and any hidden fields.

fbq('track', 'Lead'): This is a Meta Pixel standard event call. When executed, the Pixel JavaScript sends a Lead event to Meta via the visitor's browser. Because it runs in the browser, it has access to the _fbp cookie (first-party browser ID) and the _fbc cookie (click ID from fbclid parameter), which help Meta match the event back to the ad click.

1. Add the callback function to your index.html. Before the closing </body> tag, add this script:

<script>
  function typeformSubmitted(event) {
    // event.responseId contains the Typeform response ID
    console.log('Typeform submitted. Response ID:', event.responseId);

    // Fire the Meta Lead event via Pixel
    if (typeof fbq === 'function') {
      fbq('track', 'Lead', {
        content_name: 'Discovery Application',
        content_category: 'B2B Lead'
      });
      console.log('Meta Lead event fired via Pixel.');
    } else {
      console.error('fbq not found — Meta Pixel may not be loaded.');
    }
  }
</script>

2. Commit and push. Wait for deployment.
3. Open your site. Open the browser developer console (F12 → Console). Submit the Typeform with test data.
4. Check the console. You should see both log messages: the response ID and the Lead event confirmation.
5. Check Meta Pixel Helper. The badge should now show 2 events: PageView + Lead.
6. Check Events Manager. Go to Events Manager → Overview or Test Events. You should see the Lead event.

Typeform form submission → onSubmit callback on parent page.

No automation platform involved. This is a pure browser-side event: Typeform SDK → JavaScript callback → Pixel → Meta.

None. Fully automated — fires every time a visitor submits the form.

Browser-side. The visitor's browser sends the event to Meta. This means: the visitor's IP address and user agent are automatically included; the _fbp and _fbc cookies provide identity; but the visitor's email and phone are not sent (the Pixel standard event call does not include form field data by default).

event_name: "Lead"
event source: Pixel (browser)
action_source: "website" (implicit — browser events are always website)
user_data: _fbp, _fbc, IP, user agent (auto-captured)
custom_data: content_name, content_category (from our fbq call)

Lead is a Meta standard event. It appears automatically in Events Manager once received. No Custom Conversion needed.

Submit the Typeform. Check: (1) browser console for log messages, (2) Pixel Helper for Lead event, (3) Events Manager for Lead event.

• Console shows "Typeform submitted" and "Meta Lead event fired"
• Pixel Helper shows Lead event
• Events Manager shows Lead from Pixel source

Lead event in Events Manager with source "Pixel." Event Match Quality may be low because the browser event only carries cookies and IP — no hashed email or phone. This is normal for browser-side events and is one reason the Conversions API exists.

• Typeform submission fires a Lead event via Pixel
• Lead visible in Events Manager
• You can explain: "The Typeform embed SDK calls my function when the form is submitted. My function calls fbq('track','Lead'), which makes the Pixel send a Lead event to Meta through the visitor's browser."

After Typeform submission, redirect the visitor to a Calendly booking page.

In the client's funnel, after submitting the qualifying form, the visitor should be able to book a discovery call. This is a navigation step — moving the visitor from the form to the booking page.

Visitor submits Typeform
    │
    ▼ onSubmit callback fires
    │
    ├── fbq('track', 'Lead')   ← Handshake #1
    │
    └── window.location.href = Calendly URL   ← redirect
    │
    ▼
Visitor lands on Calendly booking page

Redirect mechanism: In the typeformSubmitted callback, after firing the Lead event, we redirect the visitor to the Calendly booking page. This is a simple JavaScript redirect. Alternatively, Typeform's own "Redirect on completion" setting (in form settings) can handle this — but that may require a paid Typeform plan.

• Layer 4 complete (Lead event working)
• A Calendly account (free plan works)

1. Create a Calendly account at calendly.com if you don't have one.
2. Create an event type. Click "Create" → "One-on-One" → name it "Discovery Call" → set duration (30 min) → Save. Note your booking URL: https://calendly.com/yourusername/discovery-call.
3. Update the typeformSubmitted function in your index.html to add the redirect:

<script>
  function typeformSubmitted(event) {
    console.log('Typeform submitted. Response ID:', event.responseId);

    // Fire the Meta Lead event via Pixel
    if (typeof fbq === 'function') {
      fbq('track', 'Lead', {
        content_name: 'Discovery Application',
        content_category: 'B2B Lead'
      });
      console.log('Meta Lead event fired via Pixel.');
    }

    // Redirect to Calendly after a short delay
    // (delay gives the Pixel time to send the Lead event)
    setTimeout(function() {
      window.location.href =
        'https://calendly.com/YOURUSERNAME/discovery-call';
    }, 1500);
  }
</script>

4. Replace YOURUSERNAME with your actual Calendly username.
5. Commit and push.
6. Test: Submit the Typeform. After ~1.5 seconds, you should be redirected to the Calendly booking page.

Submit the form → verify Lead event fires (check Pixel Helper quickly before redirect) → confirm you land on the Calendly booking page.

• Typeform submission triggers redirect to Calendly
• Lead event still fires before the redirect
• Calendly booking page loads correctly

• Typeform submission → Lead event → Calendly redirect (in that order)
• You can explain: "This is a navigation step, not a tracking step. The redirect moves the visitor to Calendly. The Schedule event is captured server-side in Layer 9, not here."

Create a Google Sheet that tracks every lead through the entire funnel. This sheet serves as both a reporting tool and a trigger source for Handshakes #3 and #4.

The client needs visibility into the full funnel. The sheet also serves as the trigger mechanism for the "attended" and "qualified" events — when a team member updates a row, it triggers an automation. This is where the manual business decisions (attendance, qualification) become automated technical transmissions.

1. Create a new Google Sheet. Go to sheets.google.com → Blank spreadsheet → Name it "ScaleUp Partner — Lead Tracker."
2. Create the header row in Row 1 with these columns:

3. Add a Lead_ID formula. In cell A2, enter: =IF(D2="","",TEXT(ROW()-1,"0000")). This generates a simple sequential ID when an email is present. Drag down for 100 rows. In production, you would use a more robust ID (e.g., combining a date hash with a counter).
4. Add a test row. In row 2, enter test data: a name, email (test@example.com), phone (+1234567890), and country. Leave Attended, Qualified, Signed as empty (they'll be filled manually later).
5. Share the sheet. Click "Share" → add your Google account (the one n8n will use) as Editor. If using n8n Cloud or a service account, share with the appropriate email.

• Google Sheet created with all 17 columns
• Lead_ID formula working
• Test row populated
• Sheet shared for n8n access
• You can explain: "Columns J (Attended) and K (Qualified) are manual — they represent human business decisions. When a team member changes these to TRUE, it triggers an automation that sends the corresponding event to Meta."

Learn the core concepts of n8n by building a simple test workflow. Understand nodes, triggers, data flow, and executions before building the real CAPI workflows.

n8n is where you will build the four server-side CAPI workflows (Handshakes #2–#5). Before doing that, you need to understand how n8n works: what a workflow is, how data flows between nodes, how webhooks trigger workflows, and how to inspect the data at each step.

Workflow: A sequence of connected nodes that processes data. Equivalent to a Zapier "Zap," but with more visibility and control.

Node: A single operation in a workflow — a trigger, a data transformation, an HTTP request, a conditional branch. Equivalent to a Zapier "step."

Trigger node: The first node in a workflow. It starts the workflow when an event occurs. Examples: Webhook (receives an HTTP request), Schedule (runs on a timer), Google Sheets Trigger (detects row changes).

Webhook: An HTTP endpoint that n8n creates for you. When an external service (Calendly, Stripe) sends an HTTP POST to this URL, n8n triggers the workflow.

HTTP Request node: Makes an HTTP request to an external API. This is what you will use to send events to Meta's Conversions API.

Code node: Runs custom JavaScript. You will use this for SHA-256 hashing of PII and event ID generation.

Execution: One run of a workflow. n8n logs every execution so you can see the input/output of each node — this is invaluable for debugging.

Expressions: Dynamic values in node fields. Syntax: {{ $json.fieldName }} to reference data from a previous node's output.

Credentials: Stored authentication details (API keys, OAuth tokens). Configured once, reusable across workflows.

1. Open n8n. Go to http://localhost:5678 (self-hosted) or your n8n Cloud URL. Create an account if prompted.
2. Create a new workflow. Click "Add Workflow" → name it "Test — Webhook Echo."
3. Add a Webhook trigger. Click "+" to add a node → search "Webhook" → select "Webhook." Set:
   HTTP Method: POST
   Path: test-echo
   This creates an endpoint like http://localhost:5678/webhook/test-echo (or your cloud URL equivalent).
4. Add a Set node. Click "+" → search "Set" → select "Edit Fields (Set)." Add a field:
   Name: received_message
   Value: {{ $json.body.name || 'no name provided' }}
   Add another field:
   Name: timestamp
   Value: {{ new Date().toISOString() }}
5. Add a Respond to Webhook node. Click "+" → search "Respond" → select "Respond to Webhook." Set Response Body to:
   {{ JSON.stringify({ status: 'ok', received: $json.received_message, at: $json.timestamp }) }}
6. Connect the nodes: Webhook → Set → Respond to Webhook.
7. Activate the workflow. Toggle the "Active" switch in the top right.
8. Test it. Open a terminal and run:

curl -X POST http://localhost:5678/webhook/test-echo \
  -H "Content-Type: application/json" \
  -d '{"name": "Test Student", "email": "test@example.com"}'

You should receive a JSON response with the status, received name, and timestamp.

9. Inspect the execution. In n8n, go to "Executions" (left sidebar). Click the latest execution. Click each node to see its input and output data. This is how you will debug every workflow in this lab.

• Test workflow built: Webhook → Set → Respond
• Workflow activated and responding to curl requests
• Execution visible in n8n's execution log
• You can inspect input/output data at each node
• You can explain: "A webhook trigger creates an HTTP endpoint. When something sends a POST request to that endpoint, n8n runs the workflow. I can inspect every step."

Understand the exact structure of a Conversions API request. Build and send a manual CAPI event from n8n, with proper PII hashing.

Before building automated workflows, you must understand what happens at the HTTP level when you "send an event to Meta." Every Zapier action and every n8n HTTP Request node is ultimately making this same HTTP POST request. If you understand the raw API, you can debug any integration on any platform.

YOUR SERVER (n8n)
    │
    │  HTTP POST
    │  https://graph.facebook.com/v21.0/{PIXEL_ID}/events
    │
    │  Headers:
    │    Content-Type: application/json
    │
    │  Body (JSON):
    │  {
    │    "data": [{
    │      "event_name": "Lead",
    │      "event_time": 1700000000,
    │      "event_id": "unique-id-here",
    │      "action_source": "website",
    │      "user_data": {
    │        "em": ["sha256-hashed-email"],
    │        "ph": ["sha256-hashed-phone"],
    │        "fn": ["sha256-hashed-first-name"],
    │        "ln": ["sha256-hashed-last-name"],
    │        "client_ip_address": "1.2.3.4",
    │        "client_user_agent": "Mozilla/5.0..."
    │      },
    │      "custom_data": {}
    │    }],
    │    "access_token": "YOUR_ACCESS_TOKEN",
    │    "test_event_code": "TEST12345"
    │  }
    │
    ▼
META GRAPH API
    │
    ▼
Response: {"events_received": 1, "messages": []}

Endpoint: https://graph.facebook.com/v21.0/{PIXEL_ID}/events — replace {PIXEL_ID} with your Pixel ID. Verify the current API version at developers.facebook.com/docs/graph-api/changelog.

Required fields in every CAPI event:

SHA-256 hashing: All PII in user_data must be hashed with SHA-256 before sending. The process: normalize (lowercase, trim whitespace) → hash. Meta hashes its own data the same way and compares hashes to match users.

Hashing rules:

Fields that are NOT hashed: client_ip_address, client_user_agent, fbc, fbp, external_id.

1. Create a new n8n workflow. Name it "Test — Manual CAPI Event."
2. Add a Manual Trigger. Search "Manual" → select "Manual Trigger." This lets you run the workflow on demand by clicking "Test Workflow."
3. Add a Code node (search "Code"). This node will build the CAPI payload with proper hashing. Paste this JavaScript:

const crypto = require('crypto');

// --- Test identity data ---
const email = 'test@example.com';
const phone = '+1 (234) 567-8900';
const firstName = 'Test';
const lastName = 'Student';

// --- Hashing helper ---
function sha256(value) {
  return crypto.createHash('sha256')
    .update(value)
    .digest('hex');
}

// --- Normalize and hash ---
const hashedEmail = sha256(email.toLowerCase().trim());
const hashedPhone = sha256(phone.replace(/[^0-9]/g, ''));
const hashedFn = sha256(firstName.toLowerCase().trim());
const hashedLn = sha256(lastName.toLowerCase().trim());

// --- Build the CAPI payload ---
const payload = {
  data: [{
    event_name: 'Lead',
    event_time: Math.floor(Date.now() / 1000),
    event_id: 'test-lead-' + Date.now(),
    action_source: 'website',
    user_data: {
      em: [hashedEmail],
      ph: [hashedPhone],
      fn: [hashedFn],
      ln: [hashedLn],
      client_ip_address: '1.2.3.4',
      client_user_agent: 'Mozilla/5.0 (Lab Test)'
    },
    custom_data: {
      content_name: 'Discovery Application'
    }
  }],
  access_token: 'YOUR_ACCESS_TOKEN',
  test_event_code: 'YOUR_TEST_EVENT_CODE'
};

return [{ json: payload }];

4. Replace YOUR_ACCESS_TOKEN and YOUR_TEST_EVENT_CODE with your actual values from Layer 1.
5. Add an HTTP Request node. Configure:
   Method: POST
   URL: https://graph.facebook.com/v21.0/YOUR_PIXEL_ID/events
   Body Content Type: JSON
   Body: use Expression → {{ JSON.stringify($json) }}
   (Or set "Send Body" → "Specify Body" → "JSON" and reference the previous node's output)
6. Connect: Manual Trigger → Code → HTTP Request.
7. Click "Test Workflow."
8. Inspect each node's output. Click the Code node — verify the hashed values. Click the HTTP Request node — verify the response is {"events_received": 1}.
9. Check Events Manager → Test Events. Your Lead event should appear with "Conversions API" as the source.

• Manual CAPI event sent from n8n
• Event visible in Events Manager → Test Events with "Conversions API" source
• You can read the Code node output and identify each hashed field
• You can explain the difference between client_ip_address (not hashed) and em (hashed)
• You can explain: "Every CAPI integration — n8n, Zapier, or any other tool — is making this same HTTP POST. The only difference is the user interface."

Build an automated workflow: when a Calendly booking occurs, send a Schedule event to Meta via the Conversions API.

This is the first fully automated server-side handshake. A visitor books a call on Calendly → Calendly sends a webhook to n8n → n8n transforms the data and sends it to Meta. The client specifically requested this as "Zap 1."

CALENDLY
  │ invitee.created webhook
  │ (name, email, questions_and_answers, event URI)
  ▼
N8N WEBHOOK TRIGGER
  │
  ▼
CODE NODE (extract data, normalize, SHA-256 hash)
  │
  ▼
HTTP REQUEST NODE
  │ POST https://graph.facebook.com/v21.0/{PIXEL_ID}/events
  │ event_name: "Schedule"
  │ user_data: { em, ph, fn, ln }
  │ action_source: "website"
  ▼
META EVENTS MANAGER → Schedule received

Calendly webhooks: Calendly can send HTTP POST notifications when events occur. The key event for us is invitee.created — fired when someone books a meeting. The webhook payload includes the invitee's name, email, and answers to any custom questions you've set up. Phone number may be included if you've added a phone field to the booking form.

• Layers 7–8 complete (n8n fundamentals + CAPI fundamentals)
• Calendly account with a "Discovery Call" event type (from Layer 5)
• n8n running with accessible webhook URL (ngrok tunnel if self-hosted)

1. Create a new n8n workflow. Name it "Handshake #2 — Calendly → Schedule."
2. Add a Webhook trigger node. Set:
   HTTP Method: POST
   Path: calendly-schedule
   Note the webhook URL (e.g., https://your-tunnel.ngrok.io/webhook/calendly-schedule).
3. Register the webhook with Calendly. Option A — use n8n's built-in Calendly Trigger node (requires connecting your Calendly account via OAuth or Personal Access Token). Option B — manually register via the Calendly API:

curl -X POST https://api.calendly.com/webhook_subscriptions \
  -H "Authorization: Bearer YOUR_CALENDLY_PAT" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-n8n-url/webhook/calendly-schedule",
    "events": ["invitee.created"],
    "organization": "https://api.calendly.com/organizations/YOUR_ORG_ID",
    "scope": "organization"
  }'

To find your organization URI, call: curl -H "Authorization: Bearer YOUR_PAT" https://api.calendly.com/users/me and look at current_organization.

4. Add a Code node for data extraction and hashing. The Calendly webhook payload structure includes the invitee's name and email in payload.invitee:

const crypto = require('crypto');

function sha256(val) {
  return crypto.createHash('sha256').update(val).digest('hex');
}

// Extract from Calendly webhook payload
const invitee = $json.body?.payload?.invitee || $json.payload?.invitee || {};
const event = $json.body?.payload?.event || $json.payload?.event || {};

const email = (invitee.email || '').toLowerCase().trim();
const name = (invitee.name || '').trim();
const nameParts = name.split(' ');
const firstName = nameParts[0] || '';
const lastName = nameParts.slice(1).join(' ') || '';

// Look for phone in questions_and_answers if configured
const questions = invitee.questions_and_answers || [];
const phoneAnswer = questions.find(q =>
  q.question.toLowerCase().includes('phone'));
const phone = phoneAnswer ? phoneAnswer.answer.replace(/[^0-9]/g, '') : '';

// Calendly event URI — used as the basis for event_id
const calendlyEventUri = event.uri || '';
const calendlyEventId = calendlyEventUri.split('/').pop() || '';

// Build CAPI payload
const payload = {
  data: [{
    event_name: 'Schedule',
    event_time: Math.floor(Date.now() / 1000),
    event_id: 'schedule-' + calendlyEventId,
    action_source: 'website',
    user_data: {
      em: email ? [sha256(email)] : [],
      ph: phone ? [sha256(phone)] : [],
      fn: firstName ? [sha256(firstName.toLowerCase())] : [],
      ln: lastName ? [sha256(lastName.toLowerCase())] : []
    }
  }],
  access_token: 'YOUR_ACCESS_TOKEN',
  test_event_code: 'YOUR_TEST_EVENT_CODE'
};

return [{ json: payload }];

5. Add an HTTP Request node. Configure:
   Method: POST
   URL: https://graph.facebook.com/v21.0/YOUR_PIXEL_ID/events
   Send Body: JSON, set to expression {{ JSON.stringify($json) }}
6. Connect: Webhook → Code → HTTP Request.
7. Activate the workflow.
8. Test it. Go to your Calendly booking page and book a test appointment using a test email. After booking, check n8n's execution log to verify the workflow ran. Check Events Manager → Test Events for the Schedule event.

Calendly invitee.created webhook → n8n Webhook node.

None. Fully automated.

Server-to-server. n8n sends the HTTP POST to Meta. No browser involved.

event_name: "Schedule" (standard event)
action_source: "website"
event_id: "schedule-{calendly_event_id}" (for deduplication)
user_data: em, ph, fn, ln (all SHA-256 hashed)

Schedule is a Meta standard event. It appears automatically in Events Manager. No Custom Conversion required.

• Calendly booking triggers n8n workflow
• n8n execution shows Code node output with hashed data
• HTTP Request node returns {"events_received": 1}
• Schedule event visible in Events Manager → Test Events

• Calendly booking → n8n workflow → CAPI → Schedule event in Meta
• Identity data (email, name) properly hashed
• Event ID derived from Calendly event URI (stable, not random)
• You can explain: "When someone books on Calendly, Calendly sends a webhook to n8n. n8n extracts the invitee's email and name, hashes them with SHA-256, builds a CAPI payload with event_name 'Schedule', and sends it to Meta via HTTP POST."

Build the workflow for the CallAttended event: when a team member marks a lead as having attended the call (in Google Sheets), send the event to Meta.

The client requested: "Call attended (marked in Calendly) → Fire Meta custom event 'CallAttended'." As we identified in Part 2, Calendly does not have an "attended" status. The real architecture uses Google Sheets as the trigger: a human marks Attended = TRUE, and the automation fires.

DISCOVERY CALL OCCURS
    │
    ▼ (human decision)
TEAM MEMBER opens Google Sheet
    │
    ▼ (manual action)
Sets column J (Attended) = TRUE
    │
    ▼ (automatic trigger)
N8N — Google Sheets Trigger (row updated)
    │
    ▼ (condition check)
IF node: Attended = TRUE AND CallAttended_Sent is empty
    │
    ▼ (data extraction)
CODE NODE: read email, phone from sheet row → SHA-256 hash
    │
    ▼ (API call)
HTTP REQUEST: POST to CAPI → event_name: "CallAttended"
    │
    ▼ (record keeping)
GOOGLE SHEETS NODE: write timestamp to CallAttended_Sent column
    │
    ▼
META EVENTS MANAGER → CallAttended received

Manual business decision vs automated transmission: This is the clearest example of the separation. "Did the prospect attend the call?" is a human judgment. "Send the CallAttended event to Meta" is an automated technical step. The Google Sheet is the bridge between the two worlds.

Duplicate-send prevention: If someone edits the Attended column again (e.g., corrects a typo in another column on the same row), the Google Sheets trigger may fire again. Without protection, Meta would receive a duplicate CallAttended event. Column O (CallAttended_Sent) prevents this: the workflow only fires if this column is empty, and it fills the column with a timestamp after successful transmission.

1. Create a new n8n workflow. Name it "Handshake #3 — Attendance → CallAttended."
2. Add a Google Sheets Trigger. Connect your Google account (n8n will ask for OAuth permission). Configure:
   Spreadsheet: Select your "Lead Tracker" sheet
   Sheet: Sheet1 (or whatever your sheet name is)
   Trigger On: Row Updated
   Poll interval: Every minute (for testing; increase in production)
3. Add an IF node. Condition: {{ $json.Attended }} equals TRUE AND {{ $json.CallAttended_Sent }} is empty.
4. Add a Code node (connected to the IF node's "true" output):

const crypto = require('crypto');

function sha256(val) {
  return crypto.createHash('sha256').update(val).digest('hex');
}

const email = ($json.Email || '').toLowerCase().trim();
const phone = ($json.Phone || '').replace(/[^0-9]/g, '');
const name = ($json.Name || '').trim();
const nameParts = name.split(' ');
const firstName = nameParts[0] || '';
const lastName = nameParts.slice(1).join(' ') || '';
const leadId = $json.Lead_ID || '';

const payload = {
  data: [{
    event_name: 'CallAttended',
    event_time: Math.floor(Date.now() / 1000),
    event_id: 'callattended-' + leadId,
    action_source: 'system_generated',
    user_data: {
      em: email ? [sha256(email)] : [],
      ph: phone ? [sha256(phone)] : [],
      fn: firstName ? [sha256(firstName.toLowerCase())] : [],
      ln: lastName ? [sha256(lastName.toLowerCase())] : [],
      external_id: leadId ? [sha256(leadId)] : []
    }
  }],
  access_token: 'YOUR_ACCESS_TOKEN',
  test_event_code: 'YOUR_TEST_EVENT_CODE'
};

return [{ json: { ...payload, _rowNumber: $json._rowNumber || $json.rowIndex } }];

5. Add an HTTP Request node. Same configuration as Layer 9 — POST to CAPI endpoint.
6. Add a Google Sheets node (Update Row). Configure:
   Spreadsheet: Lead Tracker
   Sheet: Sheet1
   Row Number: {{ $json._rowNumber }} (from the Code node output)
   Column O (CallAttended_Sent): {{ new Date().toISOString() }}
7. Connect: Google Sheets Trigger → IF → (true) Code → HTTP Request → Google Sheets Update.
8. Activate the workflow.
9. Test: Open your Google Sheet. In a test row that has an email, set Attended = TRUE. Wait for the poll interval. Check n8n execution log, then Events Manager.

• Setting Attended = TRUE triggers the n8n workflow
• CallAttended event appears in Events Manager → Test Events
• CallAttended_Sent column is filled with a timestamp
• Setting Attended = TRUE again on the same row does NOT send a duplicate event (the IF node blocks it because CallAttended_Sent is no longer empty)

• Attended = TRUE → CallAttended event sent to Meta
• Duplicate prevention working (CallAttended_Sent column)
• Custom event name CallAttended visible in Events Manager
• You can explain: "CallAttended is a custom event name — not a Meta standard event. I chose this name to match the client's request. It appears in Meta automatically once received. The trigger is a human action (marking attendance in a sheet), but the transmission is automated."

Build the workflow for the QualifiedLead event: when Qualified = TRUE in Google Sheets, send the event to Meta.

This is architecturally identical to Layer 10 — same trigger mechanism (Google Sheets row update), same conditional logic (check column + deduplication guard), same CAPI transmission pattern. The only differences are: the column being watched (K: Qualified instead of J: Attended), the event name (QualifiedLead instead of CallAttended), and the deduplication column (P: QualifiedLead_Sent instead of O: CallAttended_Sent).

Same as Layer 10, but:
- Watch column: K (Qualified)
- Guard column: P (QualifiedLead_Sent)
- event_name: "QualifiedLead"
- event_id: "qualifiedlead-{Lead_ID}"

1. Create a new n8n workflow. Name it "Handshake #4 — Qualified → QualifiedLead."
2. Duplicate the Layer 10 workflow (or build from scratch following the same pattern).
3. Change the IF node: Check Qualified = TRUE AND QualifiedLead_Sent is empty.
4. Change the Code node: Set event_name: 'QualifiedLead' and event_id: 'qualifiedlead-' + leadId.
5. Change the Google Sheets Update node: Write to column P (QualifiedLead_Sent) instead of column O.
6. Activate and test: Set Qualified = TRUE on a test row. Verify in Events Manager.

• Qualified = TRUE → QualifiedLead event sent to Meta
• Duplicate prevention working (QualifiedLead_Sent column)
• Setting Qualified = TRUE again does not re-send
• QualifiedLead visible in Events Manager → Test Events

• Handshake #4 working end-to-end
• You can explain: "This is the same pattern as Handshake #3. The trigger is a manual column update, the guard column prevents duplicates, and the event is sent to Meta via CAPI."

Build the workflow for the Purchase event: when a Stripe payment is received, send the event to Meta with the transaction value and currency.

This is the most valuable signal in the funnel. A Purchase event with value tells Meta exactly how much revenue each conversion generates — enabling return-on-ad-spend (ROAS) optimization.

CLIENT PAYS VIA STRIPE
    │
    ▼ (Stripe sends webhook)
    │ checkout.session.completed
    │ (customer email, payment amount, currency)
    │
N8N WEBHOOK TRIGGER
    │
    ▼
CODE NODE
    │ Extract: email, amount (convert cents → whole), currency
    │ SHA-256 hash email
    │ Generate event_id from Stripe session/payment ID
    │
    ▼
HTTP REQUEST → CAPI
    │ event_name: "Purchase"
    │ custom_data: { value: 1400.00, currency: "EUR" }
    │ user_data: { em: [hashed_email] }
    │
    ▼
META EVENTS MANAGER → Purchase with value received

Stripe test mode: Every Stripe account has a test mode with separate API keys. Test mode uses test card numbers (like 4242 4242 4242 4242) and no real money is charged. Webhooks in test mode work the same as production.

Amounts in cents: Stripe reports amounts in the currency's smallest unit. For EUR, this means cents. A payment of €1,400.00 is reported as 140000 in Stripe. You must divide by 100 to get the actual amount for Meta's value field.

Purchase as a standard event: Purchase is a Meta standard event. It supports value and currency in custom_data, which enables ROAS-based optimization in Ads Manager.

• Layers 7–8 complete
• A Stripe account (free to create, test mode is free)

1. Create or log into your Stripe account at dashboard.stripe.com.
2. Switch to Test Mode. Toggle "Test mode" in the top right of the Stripe dashboard. Confirm the badge says "TEST DATA."
3. Create a test product. Go to Products → Add Product → Name: "Monthly Retainer" → Price: €1,400.00 EUR (recurring, monthly). Create a second price: €1,700.00 EUR. This simulates the client's two contract values.
4. Create a new n8n workflow. Name it "Handshake #5 — Stripe → Purchase."
5. Add a Webhook trigger node. Path: stripe-purchase. Note the URL.
6. Register the webhook in Stripe. Go to Stripe Dashboard → Developers → Webhooks → Add endpoint:
   URL: your n8n webhook URL
   Events to send: checkout.session.completed
   Click "Add endpoint."
7. Add a Code node:

const crypto = require('crypto');

function sha256(val) {
  return crypto.createHash('sha256').update(val).digest('hex');
}

// Extract from Stripe webhook
const session = $json.body?.data?.object || $json.data?.object || {};

const email = (session.customer_details?.email
  || session.customer_email || '').toLowerCase().trim();

// Stripe amounts are in cents — convert to whole currency units
const amountInCents = session.amount_total || 0;
const value = amountInCents / 100;
const currency = (session.currency || 'eur').toUpperCase();

// Stripe session/payment ID — stable identifier for event_id
const stripeSessionId = session.id || '';
const paymentIntent = session.payment_intent || '';

const payload = {
  data: [{
    event_name: 'Purchase',
    event_time: Math.floor(Date.now() / 1000),
    event_id: 'purchase-' + (paymentIntent || stripeSessionId),
    action_source: 'website',
    user_data: {
      em: email ? [sha256(email)] : [],
      external_id: stripeSessionId ? [sha256(stripeSessionId)] : []
    },
    custom_data: {
      value: value,
      currency: currency
    }
  }],
  access_token: 'YOUR_ACCESS_TOKEN',
  test_event_code: 'YOUR_TEST_EVENT_CODE'
};

return [{ json: payload }];

8. Add an HTTP Request node. POST to CAPI endpoint (same as previous layers).
9. Connect: Webhook → Code → HTTP Request.
10. Activate the workflow.
11. Test with Stripe's test mode. In the Stripe dashboard, go to Payments → create a test payment using the Stripe checkout flow, or trigger a webhook event manually: Developers → Webhooks → your endpoint → "Send test webhook" → select checkout.session.completed → Send.
12. Alternatively, create a test Checkout Session using the Stripe CLI or a simple curl (this sends a real-looking webhook):

# Install Stripe CLI, then:
stripe trigger checkout.session.completed

13. Verify: Check n8n execution log. Check Events Manager → Test Events for a Purchase event with the correct value.

• Stripe test payment triggers n8n workflow
• Purchase event appears in Events Manager with correct value and currency
• Value shows as €1,400.00 or €1,700.00 (not 140000 or 170000)

• Stripe payment → n8n → CAPI → Purchase event with value in Meta
• Value correctly converted from cents to whole currency units
• Event ID derived from Stripe payment_intent ID (stable)
• You can explain: "The Purchase event is the most valuable signal because it carries revenue data. Meta can use this to calculate ROAS and optimize ads for revenue, not just conversions."

Reproduce the four CAPI workflows (Handshakes #2–#5) in Zapier. The client specifically requested Zapier — this is the client-facing deliverable.

The client said "Build 4 Zapier Automations." They don't have Zapier yet and need guidance on plan selection. You've already built and tested the architecture in n8n. Now you translate it to Zapier, understanding what Zapier abstracts and what it exposes.

1. Create a Zapier account at zapier.com (free trial of Professional available).
2. Create a new Zap. Name: "Calendly → Meta Schedule."
3. Trigger: Search for "Calendly" → select "Invitee Created" event.
   Connect your Calendly account (OAuth flow).
   Zapier will ask for the event scope — select your "Discovery Call" event type.
   Test: Zapier will pull a recent booking as sample data.
4. Action: Search for "Facebook Conversions" → select "Send Event" action (or "Send Other Event" if Schedule is not listed as a preset).
   Connect your Meta account (OAuth flow — must have access to the Pixel/Dataset).
   Dataset: Select your Dataset/Pixel.
   Event Name: Schedule
   Event Time: Use Zapier's timestamp formatter to get Unix time, or map Calendly's created_at field.
   Action Source: website
   Email: Map to Calendly's Invitee Email field. (Zapier's Facebook Conversions app handles hashing automatically.)
   Phone: Map to the phone field if available.
   First Name / Last Name: Map from Calendly's invitee name (you may need a Formatter step to split).
   Test Event Code: Your test event code.
5. Test the Zap. Zapier will send a test event to Meta. Verify in Events Manager.
6. Turn on the Zap.

1. Create a new Zap. Name: "Attendance → Meta CallAttended."
2. Trigger: "Google Sheets" → "New or Updated Spreadsheet Row."
   Spreadsheet: Lead Tracker
   Worksheet: Sheet1
   Trigger Column: Column J (Attended) — Zapier triggers when this specific column changes.
3. Filter (requires Professional plan): Add a Filter step:
   Only continue if: Attended = TRUE AND CallAttended_Sent is empty.
4. Action: "Facebook Conversions" → "Send Other Event."
   Event Name: CallAttended
   Action Source: system_generated
   Email: Map from sheet's Email column
   Phone: Map from sheet's Phone column
5. Action 2: "Google Sheets" → "Update Spreadsheet Row."
   Row: same row that triggered
   CallAttended_Sent: current timestamp

Same pattern as Zap 2. Change: Trigger Column to K (Qualified), Filter checks Qualified = TRUE AND QualifiedLead_Sent is empty, Event Name to QualifiedLead, and update column P.

1. Create a new Zap. Name: "Stripe → Meta Purchase."
2. Trigger: "Stripe" → "New Payment" (or "New Charge" / "Payment Intent Succeeded" depending on the client's Stripe setup).
   Connect your Stripe account (test mode).
3. Action: "Facebook Conversions" → "Send Purchase Event."
   Email: Map from Stripe's customer email
   Value: Map from Stripe's amount field. Important: Use a Formatter step to divide by 100 if Stripe sends cents.
   Currency: Map from Stripe's currency field, or hard-code EUR.

• All 4 Zaps created and turned on
• Each Zap successfully tested with sample data
• Events visible in Events Manager → Test Events
• You can explain the mapping between n8n concepts and Zapier concepts

Verify that all five events are being received correctly by Meta, with proper parameters and identity data.

1. Go to Events Manager → your Dataset → Overview.
2. For each of the five events, record:

3. Check Event Match Quality (EMQ). In Events Manager, click each event → view the "Event Match Quality" score. Meta scores the quality of identity data you're sending. Higher is better. Email alone is typically 4/10. Email + phone + name gets you 6-7/10. Adding fbc and fbp can push it to 9-10/10.
4. Check for warnings. Meta may flag issues: missing recommended parameters, low match quality, potential duplicates. Record any warnings.

• All 5 events verified in Events Manager
• Verification table completed
• You understand what EMQ means and what drives it

Understand the difference between event transmission, event configuration, and ad optimization. Configure events appropriately in Meta — but do not blindly create Custom Conversions for everything.

Three separate things:

Standard Events (Lead, Schedule, Purchase): Meta recognizes these names automatically. They appear in Events Manager with predefined categories. They can be used for optimization immediately.

Custom Events (CallAttended, QualifiedLead): These are event names Meta does not pre-define. They appear in Events Manager automatically once received. They can also be used for optimization — you can select them when creating a campaign.

Custom Conversions: A separate feature that lets you define a conversion based on rules — e.g., "Purchase events where value > €1,500." You do NOT need a Custom Conversion just to use an event for optimization. Custom Conversions are for creating filtered subsets of events.

1. Verify all 5 events appear in Events Manager. Go to Events Manager → your Dataset → Overview. All five event names should be listed.
2. Check each event's type. Click on each event → Details:
   Lead — Standard ✓
   Schedule — Standard ✓
   Purchase — Standard ✓ (with value and currency)
   CallAttended — Custom ✓
   QualifiedLead — Custom ✓
3. Verify optimization eligibility. Go to Ads Manager → create a test campaign (don't publish it) → at the Ad Set level, under "Conversion event" or "Optimization goal," look for your events in the dropdown. Standard events appear by default. Custom events should appear if they've been received.
4. Create a Custom Conversion only if needed. If the client wants to optimize for "high-value purchases only" (€1,700+ vs €1,400), then create a Custom Conversion:
   Events Manager → Custom Conversions → Create
   Name: "High-Value Purchase"
   Rule: Event = Purchase AND Value > 1500
   This is the only scenario where a Custom Conversion adds value in this project.
5. Discuss volume requirements with the client. Meta's learning phase requires approximately 50 optimization events per week. If the client gets 10 leads/week but only 1 purchase/month, optimizing for Purchase will not work — Meta won't have enough data. Start with Lead or Schedule optimization, then move to Purchase as volume grows.

• You can explain the difference between a standard event, custom event, and Custom Conversion
• You understand that Custom Conversions are not required for optimization
• You can advise the client on which event to optimize for based on volume

Understand how identity is preserved across the entire funnel — from ad click to purchase — and why this is critical for Meta's ability to attribute conversions to the correct ad.

When Meta receives a Purchase event for test@example.com, it needs to connect that purchase back to the specific ad click that started the journey. If the identity chain is broken, Meta receives the event but cannot attribute it — and the advertiser gets no optimization benefit.

META AD CLICK
│ fbclid parameter added to URL
│ _fbc cookie set in browser
│ _fbp cookie set in browser
▼
WEBSITE (your page)
│ Pixel captures: _fbc, _fbp, IP, user agent
│ URL: example.com?fbclid=abc123
▼
TYPEFORM (iframe)
│ Captures: email, phone, name, country
│ ⚠ Does NOT have access to _fbc, _fbp (different origin)
▼
CALENDLY (separate site)
│ Captures: email, name
│ ⚠ Does NOT have _fbc, _fbp
│ ⚠ Does NOT have phone (unless custom question added)
▼
GOOGLE SHEETS
│ Has: email, phone, name, country (from Typeform)
│ Has: Calendly booking info (from n8n/Zapier)
│ ⚠ Does NOT have _fbc, _fbp
▼
STRIPE
│ Has: email (from customer)
│ Has: payment amount, currency
│ ⚠ Does NOT have phone, _fbc, _fbp
▼
CAPI → META
│ Can send: em, ph, fn, ln, external_id, fbc, fbp
│ ⚠ fbc and fbp are ONLY available if captured on the website

Production strategy for _fbp/_fbc capture

// On your website, BEFORE the Typeform embed, capture the cookies:
<script>
function getCookie(name) {
  const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
  return match ? match[2] : '';
}
const fbp = getCookie('_fbp');
const fbc = getCookie('_fbc');

// Pass to Typeform via hidden fields in the embed URL:
// data-tf-hidden="fbp=VALUE,fbc=VALUE"
</script>

Then include these values in your Google Sheet and send them (unhashed) with every CAPI event as user_data.fbp and user_data.fbc.

• You can draw the identity chain from ad click to purchase
• You know which identity parameters are available at each stage
• You understand the _fbp/_fbc gap and the production strategy to close it
• You can explain: "Email is the minimum identity for CAPI matching. Adding phone improves it. Adding _fbc and _fbp dramatically improves it, but they require explicit capture on the website."

Understand how Meta deduplicates events and why stable, source-system-derived event IDs are critical.

Why duplicates occur: In a system with both browser-side (Pixel) and server-side (CAPI) tracking, the same action can generate two events. Example: a visitor submits the Typeform → the Pixel fires a Lead event → simultaneously, a Typeform webhook triggers n8n, which sends the same Lead event via CAPI. Meta now has two Lead events for the same action. Without deduplication, Meta counts it twice — inflating your conversion numbers and corrupting optimization signals.

How Meta deduplicates: Meta uses the combination of event_name + event_id within a 48-hour window. If two events have the same event_name and event_id, Meta keeps one and discards the duplicate.

Stable vs random event IDs:

• You understand why deduplication matters
• Every event in your system uses a stable, source-system-derived event_id
• You can explain: "If the browser Pixel sends Lead with event_id 'lead-abc123' and CAPI also sends Lead with event_id 'lead-abc123', Meta keeps one copy. This only works if both use the SAME event_id, which requires planning."

Deliberately create failures, diagnose them, and fix them. A freelancer who cannot troubleshoot is not worth $300.

Run one complete test journey through the entire funnel and verify every stage.

Name:      Lab TestUser
Email:     labtestuser@example.com
Phone:     +1 555 000 1234
Country:   United States

1. Visit your website. Open https://YOURUSERNAME.github.io/meta-capi-lab/. Verify PageView in Pixel Helper.
2. Submit the Typeform with the test identity. Verify: Lead event fires (Pixel Helper), console logs show "Meta Lead event fired."
3. After redirect, book a Calendly meeting. Use the same email. Complete the booking. Verify: n8n Handshake #2 workflow fires, Schedule event appears in Events Manager.
4. Add the lead to Google Sheets. If not auto-populated, manually add a row with the test identity data.
5. Set Attended = TRUE. Wait for the poll interval. Verify: n8n Handshake #3 fires, CallAttended event in Events Manager, CallAttended_Sent column populated.
6. Set Qualified = TRUE. Verify: Handshake #4 fires, QualifiedLead event in Events Manager, QualifiedLead_Sent column populated.
7. Create a Stripe test payment. Use test card 4242 4242 4242 4242, expiry any future date, CVC any 3 digits. Amount: €1,400. Verify: Handshake #5 fires, Purchase event with value in Events Manager.

After completing all steps, fill out this timeline:

• All 6 events (PageView + 5 handshakes) verified in Events Manager
• All events carry the same identity (test email)
• Google Sheet row is complete with all status columns filled
• No duplicate events sent
• Event timeline completed

Review the original client brief as a professional freelancer. Identify every assumption, ambiguity, limitation, and risk. Produce a production-ready assessment.

Re-read the Raw Client Brief from Part 1. For each major point, produce:

Additional Production Considerations

Privacy/Compliance: PII is being hashed and sent to Meta. The client should verify compliance with GDPR (EU data), cookie consent requirements, and their privacy policy. Meta's Terms of Service require that advertisers have appropriate consent.

Error handling: What happens when a CAPI call fails? Production workflows need retry logic, error notifications (email/Slack), and a dead-letter queue for failed events.

Monitoring: Who checks that the automations are still running? Set up alerts for: n8n/Zapier workflow failures, drop in event volume in Events Manager, changes to access tokens or permissions.

Documentation: The client requested a Loom video and written documentation. This should cover: how each Zap works, how to troubleshoot common failures, how to read Events Manager, and who is responsible for marking attendance/qualification.

• 1. Client problem analysis (1-page summary of what the client needs and why)
• 2. Business objectives document (separated by category)
• 3. Technical objectives document (the 20 things you must be able to do)
• 4. Requirements matrix (client said → technical reality → recommendation)
• 5. Architecture diagram (hand-drawn or digital: full funnel with all 5 handshakes)
• 6. Five-handshake matrix (trigger → platform → transport → event → identity)
• 7. Data mapping matrix (source field → transformation → CAPI field, for all events)
• 8. n8n workflows (4 working workflows: Schedule, CallAttended, QualifiedLead, Purchase)
• 9. Zapier workflows (4 working Zaps reproducing the n8n workflows)
• 10. Meta event matrix (all 5 events: type, source, parameters, EMQ)
• 11. Meta configuration record (what was configured, what was not, why)
• 12. Identity architecture document (identity chain, gap analysis, _fbp/_fbc strategy)
• 13. Deduplication design (event_id format for each event, rationale)
• 14. Testing evidence (screenshots from Events Manager for each event)
• 15. Troubleshooting report (at least 4 failures from Layer 18, diagnosed and fixed)
• 16. End-to-end event timeline (from Layer 19, with timestamps and verification)
• 17. Production architecture review (from Layer 20, including all 10 review items)
• 18. Client handover document (written guide the client can follow to troubleshoot independently)

The system is "done" when the client's business can:

• Track leads entering the funnel (Typeform submissions)
• Track bookings (Calendly discovery calls)
• Track attendance (calls that actually happen)
• Track qualification (leads evaluated as fit)
• Track signed customers/purchases (Stripe payments with value)
• Transmit all five events to Meta with sufficient identity data for attribution
• Preserve identity across the funnel so Meta can match events to ad clicks
• Measure revenue/value per conversion in Meta's reporting
• Diagnose failures when an automation stops working
• Understand the full funnel from ad click to signed contract
• Maintain the system through documentation and troubleshooting guides
• Understand the limitations (volume requirements, EMQ gaps, free-plan constraints)
• Make informed optimization decisions (which event to optimize for, when to shift)

— End of Module 1 —

MODULE 2 Conversion Tracking & Attribution Track

Shopify Tracking Diagnostic Lab

Audit, diagnose, and fix broken Meta Pixel & CAPI tracking on a Shopify store. Built from real Upwork client problems.

Requirement 1: "Meta is showing roughly 5x the real numbers"

Requirement 2: "Dual firing — browser Pixel and CAPI without event_id deduplication"

Requirement 3: "Repeated firing per single transaction"

Requirement 4: "Purchase events firing on non-purchase actions"

Requirement 5: "Incorrect or multiplied value parameters"

Requirement 6: "Audit across tag manager (GTM), site code, and server-side"

Requirement 7: "Validate corrected data against backend for at least 3 days"

Current State

The client has a Shopify store running Meta ad campaigns. Tracking is installed — Pixel fires, CAPI events arrive in Events Manager — but the data is dramatically wrong. Meta reports 5x the actual purchase volume and revenue. The client cannot make ad spend decisions because ROAS numbers are meaningless. They're flying blind on a live ad budget.

The Information Gap

The client does not know which of the 5 possible installation points is causing the duplication. They suspect "dual firing" but haven't audited systematically. They may have installed the native Meta app, then hired a developer who added GTM tracking, then installed a third-party attribution app — each adding its own Pixel/CAPI layer without removing the previous one. Nobody documented what was installed or when.

Why This Matters

Every day of inflated data is a day of wrong optimization decisions. Meta's algorithm is learning from garbage signal — it thinks 5x more people are converting than actually are, so it targets broader and shallower instead of finding the real converters. The client is burning money while the tracking is broken.

Desired State

Diagnostic Objectives

Identify every source of Meta events on the store. Map which Pixel IDs are firing, from which installation points, on which pages. Determine the exact mechanism causing over-counting.

Remediation Objectives

Remove or disable all duplicate event sources. Ensure exactly one browser-side and one server-side event path, both using the same event_id for deduplication. Fix value parameters. Fix firing conditions.

Validation Objectives

Prove the fix works with data. Compare Meta events to Shopify orders over 3+ days. Show before/after screenshots. Demonstrate that Meta purchase count matches reality.

Documentation Objectives

Write a runbook the client can follow. Include: what is installed, where, how to check it's working, what to do when it breaks, and a monthly health check procedure.

Commercial Constraints

Budget is $10–$30/hr. This is a diagnostic-heavy job — most of the time is investigation, not building. Phase 1 (diagnosis) should be fast. The client is time-sensitive because every day of bad data costs them ad spend.

The Five Installation Points

On a Shopify store, Meta tracking code can be installed in five independent locations. Each one can fire events to Meta without knowing the others exist. This is the root cause of most duplication problems — tracking was installed at different times by different people, and nobody removed the old installation when the new one went in.

Shopify's Web Pixels API & Customer Events

Since Shopify moved checkout to Checkout Extensibility (2024–2025), the old method of pasting JavaScript into checkout.liquid no longer works for most stores. Instead, Shopify publishes Customer Events — a standardized set of tracking events that any app or custom pixel can subscribe to. These events fire inside a sandboxed iframe, which means pixel code cannot access the main page's DOM, cookies (except via browser.cookie.get()), or other scripts.

Sandbox Restrictions

Tool Inventory

Set up a free Shopify store you can break and fix without consequences.

You cannot practice diagnostic work on a client's live store. You need a sandbox where you can install tracking in all 5 locations, create deliberate duplication, and verify fixes — all without risking a client's real ad data.

Shopify Partner Program — a free program that gives developers and agencies access to development tools, including unlimited development stores. A development store is a full Shopify store with no time limit, but it cannot process real payments or be accessed publicly without a password.

1. Create a Shopify Partner account. Go to partners.shopify.com. Sign up with your email. No credit card required. This gives you access to the Partner Dashboard.
2. Create a development store. In the Partner Dashboard, go to Stores → Add Store → "Create development store." Choose "Create a store to test and build" (not "Create a store for a client"). Store name: tracking-lab. Store URL will be: tracking-lab.myshopify.com.
3. Add a test product. In the store admin, go to Products → Add Product.
   Title: "Test Product"
   Price: $49.99
   Status: Active
   Add a placeholder image (any image).
   Save.
4. Enable Bogus Gateway for test orders. Settings → Payments → scroll to "Manual payment methods" or use the Bogus Gateway.
   For the Bogus Gateway: In "Payments" search for the test gateway option. Enter gateway name Bogus Gateway.
   This lets you create test orders without real payment processing.
5. Create a test order. Visit your store's storefront (preview), add the Test Product to cart, proceed to checkout, enter test customer details:
   Name: Lab TestUser
   Email: labtestuser@example.com
   Address: 123 Test Street, New York, NY 10001
   Payment: Use the Bogus Gateway (enter "1" in the card number field to simulate a successful transaction).
   Complete the order. Note the order number and the thank-you page URL.
6. Verify the order. In Shopify Admin → Orders, confirm your test order appears with the correct product and price.

• Development store created and accessible
• Test product exists with a price
• Test order completed successfully
• You know the thank-you page URL structure

Install the diagnostic tools and establish what fires on a clean store (nothing, yet).

Before you install any tracking, you need to know what the "zero state" looks like. This is your baseline. Every event you see after this point was added by a specific installation step, and you can trace it back.

1. Install Meta Pixel Helper. Go to the Chrome Web Store, search "Meta Pixel Helper," install the extension. Pin it to your toolbar.
2. Baseline audit. Open your development store in an Incognito window. Visit:
   • Homepage
   • Product page
   • Cart page
   • Checkout (start but don't complete)
   On each page, click the Pixel Helper icon. Record what you see (should be: no pixels detected).
3. Open Chrome DevTools. On any page, press F12 → Network tab → filter by facebook.com/tr.
   You should see zero requests. This confirms no Meta tracking is installed.
4. Document the baseline. Take a screenshot of Pixel Helper showing "No pixels found" on the homepage. This is your "before" state.

• Meta Pixel Helper installed and working
• Baseline audit shows zero Meta events on all pages
• You can use Chrome DevTools Network tab to filter for Meta requests

Install the official Facebook & Instagram channel app. This is the correct, Shopify-recommended way to install Meta tracking.

On real client stores, this app is almost always installed. You need to understand what it does automatically so you can recognize when other installations conflict with it.

Data Sharing Levels:

1. Install the app. In your Shopify Admin, go to Sales Channels → "+" → search "Facebook & Instagram" → Add. (If this fails on a development store, see the Free-Sandbox Limitation note in Part 7.)
2. Connect your Meta account. Follow the OAuth flow. Connect to your Meta Business Manager, select your Pixel/Dataset (the same one from Module 1 if you have one, or create a new one).
3. Set data sharing to Maximum. In the Facebook & Instagram app settings → Data Sharing → select "Maximum." This enables CAPI.
4. Verify with Pixel Helper. Open your store in Incognito. Visit:
   • Homepage → Pixel Helper should show PageView
   • Product page → ViewContent
   • Add to Cart → AddToCart
   • Complete a test order → Purchase on the thank-you page
   Record each Pixel ID shown. This is your "native app Pixel ID."
5. Verify in Events Manager. Go to Meta Events Manager → your Dataset. Under "Overview," you should see the events arriving. Check that both "Browser" and "Server" sources are listed for Purchase (indicating both Pixel and CAPI are active).
6. Record the Pixel ID. Write down the Pixel ID the native app is using. You will need this to identify conflicts later.

• Native app installed with data sharing set to Maximum
• Pixel Helper shows events on all key pages
• Events visible in Meta Events Manager with both Browser and Server sources
• You have recorded the native app's Pixel ID

Deliberately install a second, conflicting Meta Pixel in theme.liquid. This simulates the most common duplication scenario (~30% of cases).

On real client stores, a developer often pasted Meta Pixel code into theme.liquid in 2019–2022, before the native app existed or before the store owner installed it. When the native app was later added, nobody removed the old code. Both now fire independently. You need to create this scenario, see its effects, and then fix it.

1. Go to theme code editor. Shopify Admin → Online Store → Themes → your active theme → "..." → Edit Code.
2. Open theme.liquid (under Layout).
3. Paste the following code just before the closing </head> tag. Use a different Pixel ID than the native app (create a second Pixel in Meta Events Manager, or use the same one — even the same ID without matching event_id will cause duplication):

   <!-- DELIBERATELY ADDED FOR LAB: DUPLICATE PIXEL -->
   <script>
     !function(f,b,e,v,n,t,s)
     {if(f.fbq)return;n=f.fbq=function(){n.callMethod?
     n.callMethod.apply(n,arguments):n.queue.push(arguments)};
     if(!f._fbq)f._fbq=n;n.push=n;n.loaded=!0;n.version='2.0';
     n.queue=[];t=b.createElement(e);t.async=!0;
     t.src=v;s=b.getElementsByTagName(e)[0];
     s.parentNode.insertBefore(t,s)}(window, document,'script',
     'https://connect.facebook.net/en_US/fbevents.js');
     fbq('init', 'YOUR_SECOND_PIXEL_ID');
     fbq('track', 'PageView');
   </script>

   Replace YOUR_SECOND_PIXEL_ID with an actual Pixel ID (either a second Pixel you created, or the same Pixel ID as the native app).
4. Save the theme file.
5. Verify the duplication. Open your store in Incognito. Visit the homepage. Open Pixel Helper:
   • If you used a different Pixel ID: You should see TWO Pixel IDs, each firing PageView.
   • If you used the same Pixel ID: You should see ONE Pixel ID but with PageView firing TWICE.
   Either way, this is a duplication problem.
6. Complete a test order. Go through the full purchase flow. On the thank-you page, check Pixel Helper:
   • The native app fires Purchase (with CAPI in the background).
   • The theme.liquid code does NOT fire Purchase (it only has fbq('track', 'PageView')). But it fires an extra PageView on every page, including the thank-you page.
   • If you also added fbq('track', 'Purchase', ...) to the theme.liquid code, then Purchase fires twice on the browser side with different event_id values.

Install a Google Tag Manager container with a Meta Pixel tag. This simulates the most common duplication scenario (~40% of cases).

Agencies and PPC specialists love GTM. They install a GTM container, add a Meta Pixel tag, and configure triggers. When they leave, the container stays. The store owner later installs the native Meta app (or another agency does). Now GTM and the native app both fire. Nobody audits the GTM container because "it's managed by the agency."

1. Create a GTM account and container. Go to tagmanager.google.com. Create an account and a Web container. Name it "Tracking Lab."
2. Install GTM on Shopify. Copy the GTM container snippet. In Shopify, go to Online Store → Themes → Edit Code → theme.liquid. Paste the GTM <script> snippet right after the opening <head> tag. Paste the <noscript> snippet right after the opening <body> tag. Save.
3. Create a Meta Pixel tag in GTM. In GTM:
   • Tags → New → Tag Type: "Custom HTML"
   • Paste the same fbq initialization and PageView code as Layer 4, using a Pixel ID (the same or different).
   • Trigger: "All Pages"
   • Name: "Meta Pixel — All Pages"
4. Create a Purchase tag in GTM.
   • Tags → New → Tag Type: "Custom HTML"
   • Code:

   <script>
     fbq('track', 'Purchase', {
       value: {{Purchase Value}},
       currency: 'USD'
     });
   </script>

   
   • Trigger: Create a new trigger. Type: "Page View." Fire on: "Some Page Views." Condition: "Page URL contains thank_you"
   • Name: "Meta Purchase — Thank You Page"
   (For now, use a hardcoded value or GTM variable. The exact value extraction is not the point of this exercise — the duplication is.)
5. Publish the GTM container. Submit → Publish.
6. Verify the triple installation. Open your store in Incognito. Visit the homepage. Pixel Helper should now show events from THREE sources: native app, theme.liquid, and GTM.
   Complete a test order. On the thank-you page, count how many Purchase events fire.

Add legacy purchase tracking code in Shopify's Additional Scripts field. This simulates the ~15% of duplication cases caused by forgotten checkout scripts.

Before Shopify's Customer Events system existed (pre-2023), the standard way to track purchases was to paste JavaScript into Settings → Checkout → Additional Scripts. Thousands of tutorials and Shopify support articles recommended this approach. The code is still there on many stores — invisible unless you know to look for it.

1. Go to Additional Scripts. Shopify Admin → Settings → Checkout → scroll down to "Order status page" section → "Additional Scripts" textarea.
2. Paste legacy purchase tracking code:

   <script>
     // DELIBERATELY ADDED FOR LAB: LEGACY CHECKOUT SCRIPT
     if (typeof fbq !== 'undefined') {
       fbq('track', 'Purchase', {
         value: {{ checkout.total_price | money_without_currency }},
         currency: '{{ checkout.currency }}'
       });
     }
   </script>

   This uses Shopify's Liquid template variables to pull the actual order value.
3. Save.
4. Complete another test order. On the thank-you page, count the total Purchase events in Pixel Helper. You should now see Purchase firing from: native app, GTM tag, AND this Additional Scripts code. (The theme.liquid code fires PageView everywhere but may not fire Purchase unless you added it.)

• Legacy purchase code added to Additional Scripts
• Test order shows multiple Purchase events firing
• You can explain why this code fires on every thank-you page load, not just once per order

Map every Meta event source on the store into a single diagnostic document. This is the deliverable you hand to the client as "Phase 1: Diagnosis."

You cannot fix what you haven't mapped. A freelancer who says "I found a duplicate Pixel" and removes one thing may miss two other sources. The matrix forces a systematic audit of all 5 installation points before you touch anything.

1. Create the diagnostic matrix. Use a spreadsheet or table with these columns:

   Installation Point	Location	Pixel ID	Events Fired	Has event_id?	CAPI?	Status	Action
   1. Native App	Sales Channels → FB & IG	[your ID]	PageView, ViewContent, AddToCart, Purchase	Yes (automatic)	Yes (Maximum)	KEEP	This is the correct installation
   2. theme.liquid	Layout/theme.liquid, line ~45	[your ID or different]	PageView (all pages)	No	No	REMOVE	Delete the script block
   3. GTM	GTM container GTM-XXXXXX	[your ID or different]	PageView (all pages), Purchase (thank_you URL)	No	No	REMOVE	Pause or delete Meta tags in GTM
   4. Additional Scripts	Settings → Checkout	Same as #2 (uses existing fbq)	Purchase (thank-you page)	No	No	REMOVE	Delete the script
   5. Third-party apps	Settings → Customer Events	N/A	None found	N/A	N/A	N/A	No action

2. Count the damage. For one test Purchase:
   • Native app: 1 Purchase (browser) + 1 Purchase (CAPI) = 2 events, deduplicated to 1 by matching event_id
   • GTM: 1 Purchase (browser, no event_id) = counted separately
   • Additional Scripts: 1 Purchase (browser, no event_id) = counted separately
   • Total: Meta sees 3 distinct Purchase events for 1 actual order
   • If the customer reloads the thank-you page: GTM and Additional Scripts fire again, native app does not. Total could be 5+ events.

Remove all duplicate tracking sources, leaving only the native app. Verify single-fire behavior.

The fix is conceptually simple: remove everything except the one correct installation. But on a real client store, you must do it carefully — document what you're removing, take backups, and verify after each removal.

1. Duplicate your theme as a backup. Online Store → Themes → "..." → Duplicate. This gives you a rollback point.
2. Remove the theme.liquid code. Edit Code → theme.liquid → find the fbq script block you added in Layer 4 → delete the entire block (from the comment to the closing </script> tag). Save.
   Verify: Visit homepage in Incognito. Pixel Helper should show ONE fewer Pixel source.
3. Pause/remove the GTM Meta tags. Open GTM → Tags → find "Meta Pixel — All Pages" and "Meta Purchase — Thank You Page" → Pause both tags (don't delete yet, in case you need to reference them).
   Publish a new GTM container version.
   Verify: Pixel Helper should now show only the native app's events.
4. Remove the Additional Scripts code. Settings → Checkout → Additional Scripts → delete the Purchase tracking code you added in Layer 6. Save.
   Verify: Complete a test order. On the thank-you page, Pixel Helper should show exactly ONE Purchase event from the native app.
5. Final verification. Complete one more test order. Check:
   • Pixel Helper: exactly 1 Purchase event on the thank-you page
   • Events Manager: 1 Purchase (browser) + 1 Purchase (server), deduplicated to 1 event
   • No PageView duplicates on any page
   • Reload the thank-you page — Purchase should NOT fire again

• All three duplicate sources removed
• Theme backup exists for rollback
• Pixel Helper shows exactly 1 Pixel ID on all pages
• Purchase fires exactly once per test order
• Reloading the thank-you page does not re-fire Purchase

Compare Meta Events Manager data against Shopify's order records. This is the validation step that proves your fix worked.

The client said: "Validate corrected data against our backend Shopify/Stripe transaction records for at least 3 days." This is how a professional proves the fix. You don't just say "I removed the duplicates" — you show the numbers match.

Why it won't be exactly 100% match:

1. Create 5 test orders on your development store over a period of time (e.g., 5 orders spread across 1–2 hours). Use different test customer details for each.
2. Export Shopify orders. Orders → Export → CSV. Note the order count and total revenue.
3. Check Meta Events Manager. Go to Events Manager → your Dataset → Purchase event. Filter by the same time period. Note the event count.
4. Build the reconciliation table:

   Metric	Shopify Orders	Meta Events Manager	Ratio	Verdict
   Purchase count	5	5	1.0	Clean (in test environment, no ad blockers)
   Total revenue	$249.95	$249.95	1.0	Values match

5. Repeat with duplicates active (optional, for comparison). Re-enable one duplicate source, create 3 more orders, and compare again. You should see Meta reporting 6+ events for 3 orders.

Understand and improve the Event Match Quality (EMQ) score on the store's events. Fixing duplication is half the job — the other half is making sure the remaining events carry enough identity data for Meta to match them to users.

The client brief mentions "demonstrable CAPI and server-side tracking experience." A freelancer who removes duplicates but ignores EMQ has only done half the work. Low EMQ means Meta can't attribute conversions to ad clicks, which means the client's campaign optimization suffers even with accurate event counts.

Recall from Module 1: EMQ scores each event on a 1–10 scale based on the identity parameters it carries.

1. Check EMQ in Events Manager. Go to Events Manager → your Dataset → click on the Purchase event → "Event Match Quality" tab. Note the score and which parameters are contributing.
2. Identify gaps. Common gaps on Shopify:
   • fbc missing: Customer didn't arrive via Meta ad (common in test environment)
   • ph missing: Customer didn't provide phone at checkout
   • external_id not sent: Native app may not send this by default
3. Document the EMQ state. Create a table showing each parameter, whether it's being sent, and what would need to change to include it.

Encounter and diagnose the specific failure modes you'll see on real Shopify stores.

Write the maintenance runbook the client requested. This is the final deliverable.

The client brief says: "Document the final setup and provide a maintenance runbook so our team can troubleshoot." A freelancer who fixes the problem but doesn't document it will get hired again when it breaks. A freelancer who documents it earns the client's trust and a 5-star review. The review matters more than the repeat work.

Write a document with these sections:

• Runbook written with all 5 sections
• Runbook uses the client's actual Pixel ID and specific removal details
• Monthly health check can be done by a non-technical team member in 5 minutes
• Troubleshooting section covers the 3 most common breakage scenarios

• 1. Shopify development store with a test product and test orders
• 2. Baseline audit (screenshot of Pixel Helper on clean store)
• 3. Native Meta app installed with Maximum data sharing
• 4. Deliberately created triple-duplication scenario (native + theme.liquid + GTM + Additional Scripts)
• 5. Diagnostic matrix documenting all event sources, Pixel IDs, event_id presence, and CAPI status
• 6. Evidence of duplication (Pixel Helper screenshots showing multiple events per page)
• 7. All duplicate sources removed with before/after Pixel Helper screenshots
• 8. Reconciliation table: Meta Events Manager vs. Shopify Orders (post-fix)
• 9. EMQ assessment for the store's Purchase events
• 10. Debugging exercises completed (at least 4 of 6 failures diagnosed)
• 11. Client handover runbook (all 5 sections)
• 12. 2–3 sentence diagnostic approach summary (as you would write in an Upwork application for this job)

The system is "done" when:

• Meta Events Manager shows exactly 1 Purchase event per actual Shopify order
• Purchase values in Meta match Shopify order totals (same currency, same amount)
• Both "Browser" and "Server" sources appear for Purchase events in Events Manager
• Only one Pixel ID fires on any page of the store
• Meta ROAS aligns with actual Shopify revenue (ratio between 0.85 and 1.0 after 3 days)
• No duplicate event sources remain in theme code, GTM, Additional Scripts, or third-party apps
• A maintenance runbook exists that a non-technical team member can follow
• Before/after documentation with screenshots proves the fix

— End of Module 2 —

MARKET RESEARCH Upwork Market Intelligence

Automation Niches & Market Penetration

Factual breakdown of automation sub-markets on Upwork. Data sourced from Upwork's official reports, hiring pages, and third-party market analyses.

Platform Context

Upwork's AI segment reached $300M+ annualized GSV (gross services volume) with 50% year-over-year growth. Within that, the AI Integration & Automation sub-segment grew over 90% YoY. The platform has 784,000 active clients as of Q1 2026, with GSV per client rising 5% to $5,138 despite flat total GSV. AI-enabled freelancers earn approximately 40% more per hour than those who don't use AI.

YoY Growth: Automation-Adjacent Skills

From Upwork's official 2026 In-Demand Skills report (measured by completed job earnings, Feb 2026 release).

Note: "Scripting & Automation" was a fastest-growing skill in the 2025 report's Coding & Web Development category. By 2026, AI-specific skills overtook it in growth rate, though base volume for scripting/automation remains higher.

The Eight Automation Niches

Rate Comparison Across Niches

Rate data compiled from Upwork hiring pages (Aug 2026), Ciphernutz pricing guide, and Jobbers CRM freelancing guide. Upwork median rates skew lower than direct-client rates — the gap is widest in CRM consulting, where Upwork's HubSpot median ($25/hr) sits far below direct-client rates ($100–$200+/hr).

Saturation vs. Opportunity

Most Promising Niches — Ranked

"Promising" here means: growing demand, lower freelancer saturation relative to job volume, and a rate ceiling that rewards skill depth.

Key Strategic Facts

Where Your Course Covers

— End of Market Research —

MODULE 1 AI Integration & Automation Track

AI Integration Laboratory

A complete, hands-on student laboratory based on real Upwork AI integration projects.

Covers OpenAI & Claude APIs, n8n AI workflows, HubSpot CRM webhooks, Slack bots, and production prompt engineering. 16 implementation layers. Three live AI use cases delivered to a single SaaS client.

End of raw client brief. Everything above is the client's exact language.

This client is more sophisticated than most Upwork clients — they know their tools, they've defined an ICP, and they understand that AI shouldn't auto-reply to customers. That's a good sign. It also means your proposal needs to demonstrate technical depth, not just enthusiasm.

Requirement 1: "AI Lead Enrichment"

Requirement 2: "Support Ticket Triage"

Requirement 3: "Internal Knowledge Bot"

Budget & Pricing Analysis

API Cost Estimate for the Client

The client asked you to estimate their monthly API costs. This demonstrates your technical depth and builds trust.

The client said: "Please don't apply with a generic proposal." They also asked for four specific things. Address every single one.

System Architecture

                    ┌─────────────────────────┐
                    │     TRIGGER SOURCES      │
                    │                          │
                    │  HubSpot Webhook ─────┐  │
                    │  Support Widget ──────┤  │
                    │  Slack Command ───────┤  │
                    └───────────────────────┼──┘
                                            │
                                            ▼
                    ┌─────────────────────────┐
                    │     n8n MIDDLEWARE       │
                    │                          │
                    │  ┌── Receive trigger     │
                    │  ├── Fetch context data  │
                    │  ├── Build prompt        │
                    │  ├── Call LLM API        │
                    │  ├── Parse response      │
                    │  └── Route output        │
                    └───────────┬──────────────┘
                                │
               ┌────────────────┼────────────────┐
               ▼                ▼                ▼
    ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
    │   HubSpot    │  │    Slack     │  │   Logging    │
    │  (update     │  │  (post msg  │  │  (Google     │
    │   contact)   │  │   to chan)  │  │   Sheets)    │
    └──────────────┘  └──────────────┘  └──────────────┘

LLM API Selection Matrix

Why n8n (not Make, not Zapier)

The client explicitly prefers n8n with a path to self-hosting. This is a common pattern for Series A SaaS companies — they want to own their infrastructure and avoid per-execution pricing as volumes grow. At 1,500 tickets/month on Zapier, that's $75–$150/mo in Zapier costs alone. n8n cloud is ~$24/mo; self-hosted is $0.

Tool Stack Summary

Understand the anatomy of an OpenAI API call and make your first successful request.

Every OpenAI API call is an HTTP POST to a single endpoint. No SDK required — any tool that can make HTTP requests (n8n, curl, Postman) can call the API.

POST https://api.openai.com/v1/chat/completions

Headers:
  Content-Type: application/json
  Authorization: Bearer sk-proj-YOUR_API_KEY

Body:
{
  "model": "gpt-4.1-mini",
  "messages": [
    {
      "role": "system",
      "content": "You are a lead scoring assistant for a B2B SaaS company."
    },
    {
      "role": "user",
      "content": "Score this lead: Company is 'TechNova', found at technova.io, they sell analytics dashboards to mid-market retailers."
    }
  ],
  "temperature": 0.2,
  "max_tokens": 500
}

{
  "id": "chatcmpl-abc123",
  "model": "gpt-4.1-mini-2025-07-18",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "{\"score\": 72, \"fit\": \"partial\", \"summary\": \"TechNova sells analytics dashboards to mid-market retailers. Partial ICP match — right market segment (mid-market) but wrong vertical (retail, not e-commerce). Worth a discovery call if they serve Shopify Plus merchants.\"}"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 89,
    "completion_tokens": 67,
    "total_tokens": 156
  }
}

1. Create an OpenAI account. Go to platform.openai.com. Sign up and add a payment method (you'll need ~$1 of credit for this entire lab).
2. Generate an API key. Go to API Keys → Create new secret key → name it "AI Integration Lab" → copy it immediately (you can't see it again). Store it securely.
3. Make a test call. In your terminal, run:

curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-proj-YOUR_KEY" \
  -d '{
    "model": "gpt-4.1-mini",
    "messages": [
      {"role": "system", "content": "Reply with valid JSON only."},
      {"role": "user", "content": "Score this company as an ICP fit for a B2B e-commerce analytics SaaS: Acme Corp, 50 employees, Shopify Plus, $20M revenue."}
    ],
    "temperature": 0.2,
    "response_format": {"type": "json_object"}
  }'

4. Verify the response. You should get a JSON response with the model's scoring. If you get a 401 error, your API key is wrong. If you get a 429 error, you've hit a rate limit — wait a minute and retry.
5. Check your usage. Go to platform.openai.com/usage to see the API call logged with token counts and cost.

Learn the Claude API as an alternative. Many clients prefer Anthropic or want you to benchmark both providers.

POST https://api.anthropic.com/v1/messages

Headers:
  Content-Type: application/json
  x-api-key: sk-ant-YOUR_KEY
  anthropic-version: 2023-06-01

Body:
{
  "model": "claude-haiku-3-5-20241022",
  "max_tokens": 500,
  "system": "You are a lead scoring assistant for a B2B SaaS company. Always respond in valid JSON.",
  "messages": [
    {
      "role": "user",
      "content": "Score this lead: Company is 'ShopFlow', found at shopflow.com, they build inventory management for Shopify Plus stores. 80 employees, $15M ARR."
    }
  ]
}

1. Create an Anthropic account. Go to console.anthropic.com. Sign up and add billing.
2. Generate an API key. Settings → API Keys → Create Key → copy it.
3. Make a test call.

curl https://api.anthropic.com/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: sk-ant-YOUR_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-haiku-3-5-20241022",
    "max_tokens": 500,
    "system": "You are a lead scoring assistant. Always respond in valid JSON with keys: score (0-100), fit (strong/partial/weak), summary (2-3 sentences).",
    "messages": [
      {"role": "user", "content": "Score: ShopFlow, shopflow.com, inventory management for Shopify Plus, 80 employees, $15M ARR."}
    ]
  }'

Write production-grade prompts that return consistent, structured, actionable outputs. This is the single most important skill in AI integration — the difference between a demo that impresses and a system that works in production.

Rule 1: Define the output format explicitly. Never let the model decide how to format its response. Specify exact JSON keys, field types, and value constraints.

// BAD — the model invents its own format every time
"Score this lead and tell me if they're a good fit."

// GOOD — deterministic, parseable output
"Analyze this lead against our ICP. Return valid JSON with exactly these keys:
{
  \"score\": integer 0-100,
  \"fit\": \"strong\" | \"partial\" | \"weak\",
  \"icp_match\": {
    \"market_segment\": boolean,   // mid-market ($5M-$100M revenue)
    \"vertical\": boolean,          // e-commerce
    \"platform\": boolean           // Shopify Plus or custom
  },
  \"summary\": string (2-3 sentences, actionable for sales rep),
  \"next_action\": \"call\" | \"email_sequence\" | \"disqualify\"
}"

Rule 2: Give the model the ICP criteria, not just the lead data. The model doesn't know your client's ICP unless you tell it. Include the scoring rubric in the system prompt.

SYSTEM PROMPT:
"You are a lead scoring assistant for ClearMetrics, a B2B analytics platform.

Our Ideal Customer Profile (ICP):
- Market: Mid-market e-commerce companies
- Revenue: $5M-$100M annually
- Platform: Shopify Plus or custom-built e-commerce
- Pain point: Need better analytics/attribution for their ad spend
- Decision maker: VP Marketing, CMO, or Head of Growth

Scoring rubric:
- 80-100: Strong ICP match on 4-5 criteria. Prioritize for immediate outreach.
- 50-79: Partial match. Worth a discovery call to explore fit.
- 0-49: Weak match. Add to nurture sequence, don't prioritize.

Always respond in valid JSON. Never include text outside the JSON object."

Rule 3: Include few-shot examples for consistent quality. Show the model what a good output looks like. This is especially important for tone and judgment calls.

USER PROMPT:
"Here is a lead to score:

Company: StyleHub
Website content: 'StyleHub is a DTC fashion brand selling through Shopify Plus. We did $22M in revenue last year and are scaling our paid social spend.'

Example of a correct scoring output:
{
  \"score\": 88,
  \"fit\": \"strong\",
  \"icp_match\": {\"market_segment\": true, \"vertical\": true, \"platform\": true},
  \"summary\": \"StyleHub is a $22M DTC fashion brand on Shopify Plus actively scaling paid social. Strong ICP match — they need attribution analytics as they increase ad spend.\",
  \"next_action\": \"call\"
}

Now score the following lead:
Company: DataPipe
Website content: 'DataPipe provides ETL pipelines for enterprise data teams. Fortune 500 clients. Annual contracts from $200K.'"

Rule 4: Handle edge cases in the prompt, not in your code. Tell the model what to do when data is missing, ambiguous, or outside its knowledge.

"If the company website is unreachable or returns no useful content:
- Set score to 0
- Set fit to \"unknown\"
- Set summary to \"Unable to access company website. Manual research required.\"
- Set next_action to \"email_sequence\"

If the company is clearly not in e-commerce (e.g., healthcare, government, fintech):
- Score based on any partial ICP overlap
- Always explain WHY in the summary"

Get n8n running and configure credentials for OpenAI, HubSpot, and Slack.

1. Sign up for n8n cloud. Go to app.n8n.cloud → Start free trial. The free tier gives you 2,500 executions/month — plenty for development. Production will use self-hosted, but cloud is faster for building.
2. Create OpenAI credentials. In n8n: Settings → Credentials → Add Credential → search "OpenAI" → paste your API key → Save. Test it by clicking "Test Connection."
3. Create HubSpot credentials. In n8n: Add Credential → search "HubSpot" → choose "OAuth2" or "API Key."
   • For development: Use a HubSpot private app token. In HubSpot: Settings → Integrations → Private Apps → Create → name it "n8n AI Integration" → Scopes: select crm.objects.contacts.read, crm.objects.contacts.write, crm.schemas.contacts.read → Create App → copy the token.
   • Paste the token in n8n's HubSpot credential as the API key.
4. Create Slack credentials. In n8n: Add Credential → search "Slack" → choose "OAuth2." You'll need a Slack app:
   • Go to api.slack.com/apps → Create New App → From Scratch → name it "ClearMetrics AI Bot" → select your workspace.
   • OAuth & Permissions → Bot Token Scopes: add chat:write, commands, channels:read.
   • Install to Workspace → copy the Bot User OAuth Token (xoxb-...).
   • Paste in n8n's Slack credential.
5. Test each credential. Create a blank workflow → add each node (OpenAI, HubSpot, Slack) → test connection. All three should show green.

Learn to call any LLM API from n8n using the HTTP Request node. This is more flexible than the native OpenAI node and works with any provider.

n8n has a native OpenAI node, but the HTTP Request node is better for client work because: (1) it works with any LLM provider (OpenAI, Anthropic, local models) without switching nodes, (2) you can see and control the exact request being sent, (3) it's easier to debug, and (4) it matches the API documentation directly.

// Body for the HTTP Request node:
{
  "model": "gpt-4.1-mini",
  "messages": [
    {
      "role": "system",
      "content": "{{ $json.systemPrompt }}"
    },
    {
      "role": "user",
      "content": "{{ $json.userPrompt }}"
    }
  ],
  "temperature": 0.2,
  "max_tokens": 500,
  "response_format": {"type": "json_object"}
}

The LLM's response is nested inside the HTTP response body. In the next n8n node, access it with:

// The raw text response:
{{ $json.choices[0].message.content }}

// If you used JSON mode, parse it:
{{ JSON.parse($json.choices[0].message.content) }}

// Access a specific field from the JSON:
{{ JSON.parse($json.choices[0].message.content).score }}

// Token usage (for logging):
{{ $json.usage.total_tokens }}

LLM API calls fail. Rate limits (429), server errors (500), timeouts, malformed responses. In n8n, add error handling:

1. Select the HTTP Request node → Settings → On Error: Continue (using error output).
2. This creates a second output path (red) that fires when the request fails.
3. Connect the error output to a Slack notification node that alerts you (or the client) when a call fails.
4. For rate limits specifically, add an IF node that checks $json.statusCode === 429, then a Wait node (30 seconds), then retry the HTTP Request.

Set up the entry points for all three use cases. Each workflow starts with a trigger — understanding webhook architecture is essential.

Trigger 1: HubSpot Contact Created Webhook

HubSpot can send a webhook when a contact is created or updated. In HubSpot: Automation → Workflows → Create Workflow → trigger "Contact enrollment" → "Contact is created" → Action: "Send webhook" → URL: your n8n webhook URL.

// HubSpot sends this payload:
{
  "objectId": 12345,
  "properties": {
    "email": "jane@shopflow.com",
    "firstname": "Jane",
    "lastname": "Smith",
    "company": "ShopFlow",
    "website": "https://shopflow.com"
  },
  "subscriptionType": "contact.creation"
}

Trigger 2: Support Ticket Webhook (Generic)

The client uses a custom support widget that sends HTTP POST requests. This is the simplest trigger — a raw webhook.

// Support widget sends:
{
  "ticket_id": "TK-4521",
  "subject": "Can't export CSV from dashboard",
  "body": "Hi, I'm trying to export my Q3 data as CSV but the button is greyed out. I'm on the Pro plan. Browser: Chrome 126. This is urgent — I need this for a board meeting tomorrow.",
  "customer_email": "mike@retailco.com",
  "customer_name": "Mike Chen",
  "plan": "pro",
  "submitted_at": "2026-08-15T14:32:00Z"
}

Trigger 3: Slack Slash Command

When a user types /ask How do I set up SSO for a client? in Slack, Slack sends a POST to your n8n webhook.

// Slack sends (form-encoded, not JSON):
{
  "command": "/ask",
  "text": "How do I set up SSO for a client?",
  "user_id": "U0ABC123",
  "user_name": "sarah.kim",
  "channel_id": "C0DEF456",
  "response_url": "https://hooks.slack.com/commands/..."
}

1. In n8n, create three separate workflows. In each, add a Webhook node as the trigger.
2. Set HTTP Method to POST.
3. For HubSpot and support webhooks: Response Mode → "When Last Node Finishes" (HubSpot expects a 200 response). For Slack: Response Mode → "Immediately" (Slack requires a response within 3 seconds).
4. Copy each webhook's URL. You'll need these when configuring HubSpot workflows, the support widget, and the Slack app.
5. For the Slack slash command: In your Slack app settings → Slash Commands → Create New Command → Command: /ask → Request URL: paste your n8n webhook URL → Short Description: "Ask the AI knowledge bot a question" → Save.

Build the complete n8n workflow: HubSpot webhook → fetch company website → LLM scores the lead → write enrichment data back to HubSpot.

┌─────────────┐    ┌──────────────┐    ┌─────────────┐    ┌──────────────┐    ┌──────────────┐
│  Webhook     │───▶│ HubSpot:     │───▶│ HTTP Req:   │───▶│ HTTP Req:    │───▶│ HubSpot:     │
│  (trigger)   │    │ Get Contact  │    │ Fetch URL   │    │ OpenAI API   │    │ Update       │
│              │    │ (full data)  │    │ (company    │    │ (score +     │    │ Contact      │
│              │    │              │    │  website)   │    │  summarize)  │    │ (write back) │
└─────────────┘    └──────────────┘    └─────────────┘    └──────────────┘    └──────────────┘
                                              │                                      │
                                              ▼                                      ▼
                                       ┌─────────────┐                      ┌──────────────┐
                                       │ IF: website  │                      │ Google Sheet: │
                                       │ reachable?   │                      │ Log result   │
                                       └─────────────┘                      └──────────────┘

Node 1: Webhook (trigger)

1. This is the webhook you created in Layer 06. It receives HubSpot's contact creation event.
2. The incoming data includes objectId (HubSpot contact ID) and basic properties.

Node 2: HubSpot — Get Contact

1. Add a HubSpot node → Operation: Get Contact → Contact ID: {{ $json.body.objectId }}.
2. Under "Additional Fields," request: email, firstname, lastname, company, website, phone, jobtitle.
3. This fetches the full contact record since the webhook payload only includes basic fields.

Node 3: HTTP Request — Fetch Company Website

1. Add an HTTP Request node → Method: GET → URL: {{ $json.properties.website }}.
2. Set Options → Response Format: Text (we want the raw HTML).
3. Set Options → Timeout: 10000 (10 seconds — don't wait forever for a slow site).
4. Enable error handling (Continue on Error) — the site might be unreachable.

Node 4: Code Node — Extract Text from HTML

1. Add a Code node between the HTTP Request and the LLM call.
2. This strips HTML tags and extracts readable text. The LLM can't process raw HTML efficiently.

// Code node — extract text from HTML
const html = $input.first().json.data || '';
const text = html
  .replace(/<script[\s\S]*?<\/script>/gi, '')
  .replace(/<style[\s\S]*?<\/style>/gi, '')
  .replace(/<[^>]+>/g, ' ')
  .replace(/\s+/g, ' ')
  .trim()
  .substring(0, 3000); // Cap at ~3000 chars to control token usage

return [{ json: { websiteText: text, contact: $input.first().json } }];

Node 5: HTTP Request — OpenAI API Call

1. Add an HTTP Request node (as configured in Layer 05).
2. System prompt:

You are a lead scoring assistant for ClearMetrics, a B2B analytics platform for mid-market e-commerce.

ICP CRITERIA:
- Market segment: Mid-market e-commerce ($5M-$100M revenue)
- Platform: Shopify Plus, BigCommerce, or custom e-commerce
- Pain point: Needs better analytics, attribution, or data visibility
- Decision maker titles: VP Marketing, CMO, Head of Growth, Director of E-commerce

SCORING RUBRIC:
- 80-100: Strong match on 3+ criteria. Immediate outreach.
- 50-79: Partial match. Worth discovery call.
- 20-49: Weak match. Nurture sequence.
- 0-19: Not a fit. Disqualify.

Respond ONLY in valid JSON with these exact keys:
{
  "score": integer 0-100,
  "fit": "strong" | "partial" | "weak" | "disqualify",
  "summary": "2-3 sentence summary for the sales rep. Be specific about why.",
  "industry": "detected industry",
  "estimated_revenue": "best estimate or 'unknown'",
  "next_action": "immediate_call" | "discovery_email" | "nurture" | "disqualify"
}

If website content is empty or unavailable, set score to 0 and fit to "unknown".

3. User prompt: Score this lead:\n\nName: {{ $json.contact.properties.firstname }} {{ $json.contact.properties.lastname }}\nCompany: {{ $json.contact.properties.company }}\nTitle: {{ $json.contact.properties.jobtitle }}\nEmail: {{ $json.contact.properties.email }}\n\nCompany website content:\n{{ $json.websiteText }}
4. Set temperature to 0.2, max_tokens to 400, response_format to JSON mode.

Node 6: HubSpot — Update Contact

1. Add a HubSpot node → Operation: Update Contact → Contact ID: {{ $('Webhook').first().json.body.objectId }}.
2. Map the LLM's JSON response to HubSpot custom properties:

// Property mapping in the HubSpot Update node:
ai_lead_score:  {{ JSON.parse($json.choices[0].message.content).score }}
ai_fit_level:   {{ JSON.parse($json.choices[0].message.content).fit }}
ai_summary:     {{ JSON.parse($json.choices[0].message.content).summary }}
ai_next_action: {{ JSON.parse($json.choices[0].message.content).next_action }}
ai_enriched_at: {{ new Date().toISOString() }}

Test the pipeline with diverse lead types, calibrate scoring accuracy, and handle failure modes.

1. Create 10 test contacts in HubSpot covering the cases above.
2. Trigger the webhook for each (or run the workflow manually with test data).
3. Review every LLM response. Check: Is the score reasonable? Is the summary actionable? Does the next_action match?
4. If scores are consistently too high or too low, adjust the scoring rubric in the system prompt. Add examples if the model misunderstands a criterion.
5. Log results in a spreadsheet: Lead | Expected Score | Actual Score | Correct? This is your QA artifact for the client handover.

Add production-grade logging so the client can see what's happening and you can debug problems remotely.

Add a Google Sheets node at the end of the workflow that appends a row for every lead processed:

Build the first stage of the triage system: receive a ticket, classify it by category and urgency, and route it.

┌─────────────┐    ┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│  Webhook     │───▶│ HTTP Req:    │───▶│ Code Node:   │───▶│ Slack:       │
│  (ticket     │    │ OpenAI API   │    │ Format msg   │    │ Post to      │
│   incoming)  │    │ (classify)   │    │ for Slack    │    │ #support-ai  │
└─────────────┘    └──────────────┘    └──────────────┘    └──────────────┘

You are a support ticket classifier for ClearMetrics, a B2B analytics SaaS.

CATEGORIES (pick exactly one):
- bug: Software defect, broken feature, error message, crash
- feature_request: New functionality, enhancement, integration request
- billing: Invoice, payment, plan change, refund, pricing question
- how_to: Usage question, setup help, configuration, best practices
- account_access: Login issues, SSO, permissions, password reset, MFA

URGENCY LEVELS:
- critical: Production system down, data loss, security issue, revenue impact
- high: Major feature broken, blocking customer's workflow, time-sensitive
- medium: Inconvenience, workaround exists, not time-sensitive
- low: Nice-to-have, general question, feedback

RULES:
- If the customer mentions "urgent", "ASAP", "board meeting", "demo tomorrow", or similar time pressure → upgrade urgency by one level
- If the customer is on Enterprise plan → default urgency to at least "medium"
- Bug + data-related → always "critical" (potential data integrity issue)

Respond ONLY in valid JSON:
{
  "category": string,
  "urgency": string,
  "confidence": float 0-1,
  "reasoning": "one sentence explaining classification",
  "key_issue": "the core problem in 10 words or less"
}

The Code node formats the classification into a readable Slack message:

const ticket = $('Webhook').first().json.body;
const classification = JSON.parse($('OpenAI').first().json.choices[0].message.content);

const urgencyEmoji = {
  critical: '🔴',
  high: '🟠',
  medium: '🟡',
  low: '🟢'
};

const message = `${urgencyEmoji[classification.urgency]} *${classification.urgency.toUpperCase()}* — ${classification.category}

*Ticket:* ${ticket.ticket_id}
*From:* ${ticket.customer_name} (${ticket.customer_email}) — ${ticket.plan} plan
*Subject:* ${ticket.subject}
*Key issue:* ${classification.key_issue}

> ${ticket.body.substring(0, 500)}

_AI confidence: ${(classification.confidence * 100).toFixed(0)}% — ${classification.reasoning}_`;

return [{ json: { text: message, ticket, classification } }];

Add the second stage: retrieve relevant help docs and draft a response for the support rep to review.

Before the AI can draft responses, it needs access to the client's help documentation. We use a simple but effective approach: pre-process docs into a searchable format.

1. Collect the client's help docs. Ask for exports in markdown or plain text. Most help desks (Intercom, Zendesk, HelpScout) can export articles as HTML or markdown.
2. Create a document index. A JSON file that maps keywords to document chunks:

// docs-index.json — stored in n8n as a static file or a Code node
[
  {
    "id": "csv-export",
    "title": "How to Export Data as CSV",
    "keywords": ["export", "csv", "download", "data", "report"],
    "content": "To export your dashboard data as CSV:\n1. Navigate to the dashboard\n2. Click the '...' menu in the top-right\n3. Select 'Export as CSV'\n\nNote: CSV exports are available on Pro and Enterprise plans. Free plans can export up to 100 rows. If the export button is greyed out, check that your date range is selected and the dashboard has finished loading."
  },
  {
    "id": "sso-setup",
    "title": "Setting Up SSO for Your Organization",
    "keywords": ["sso", "single sign-on", "saml", "okta", "azure ad", "login"],
    "content": "SSO is available on Enterprise plans. To configure:\n1. Go to Settings → Security → SSO\n2. Select your identity provider (Okta, Azure AD, OneLogin)\n3. Enter your SAML endpoint URL and certificate\n4. Map user attributes..."
  }
  // ... more docs
]

Document retrieval logic (Code node):

// Simple keyword-based retrieval
const ticket = $('Webhook').first().json.body;
const classification = $('Classification').first().json;
const docsIndex = [/* your docs-index.json loaded here */];

// Extract keywords from ticket subject + body
const ticketText = (ticket.subject + ' ' + ticket.body).toLowerCase();

// Score each doc by keyword overlap
const scored = docsIndex.map(doc => {
  const matches = doc.keywords.filter(kw => ticketText.includes(kw));
  return { ...doc, matchCount: matches.length };
});

// Take top 3 most relevant docs
const relevant = scored
  .filter(d => d.matchCount > 0)
  .sort((a, b) => b.matchCount - a.matchCount)
  .slice(0, 3);

const context = relevant.map(d => `--- ${d.title} ---\n${d.content}`).join('\n\n');

return [{ json: { relevantDocs: context, ticket, classification } }];

You are a support agent for ClearMetrics writing a draft reply to a customer ticket.

RULES:
- Be helpful, professional, and concise
- Reference specific steps from the documentation when available
- If the docs don't cover this issue, acknowledge that and suggest next steps
- Never make up features or capabilities not in the docs
- Never promise timelines for fixes or features
- Sign off as "ClearMetrics Support" (the human rep will personalize before sending)
- Keep responses under 200 words

DOCUMENTATION CONTEXT:
{{ $json.relevantDocs }}

TICKET CLASSIFICATION:
Category: {{ $json.classification.category }}
Urgency: {{ $json.classification.urgency }}

Respond in plain text (not JSON). Write the email body only — no subject line.

Wire the classification and drafting stages together into a single workflow with the complete Slack output.

const ticket = $('Webhook').first().json.body;
const classification = JSON.parse($('Classify').first().json.choices[0].message.content);
const draftResponse = $('Draft').first().json.choices[0].message.content;

const urgencyEmoji = { critical: '🔴', high: '🟠', medium: '🟡', low: '🟢' };

const message = `${urgencyEmoji[classification.urgency]} *NEW TICKET — ${classification.urgency.toUpperCase()}*

*ID:* ${ticket.ticket_id} | *Category:* ${classification.category} | *Plan:* ${ticket.plan}
*From:* ${ticket.customer_name} <${ticket.customer_email}>
*Subject:* ${ticket.subject}

> ${ticket.body}

---

📝 *AI Draft Response:*

${draftResponse}

---
_Classification confidence: ${(classification.confidence * 100).toFixed(0)}% | AI reasoning: ${classification.reasoning}_
_⚠️ Review and edit before sending to customer_`;

return [{ json: { channel: '#support-ai', text: message } }];

Process the client's ~50 internal documents into a searchable format that the LLM can use as context.

1. Collect documents from the client. Ask them to export their Google Docs as markdown (File → Download → Markdown) and their Notion workspace as markdown (Settings → Export → Markdown & CSV).
2. Clean and chunk each document. Split long documents into sections of ~500–1000 words. Each chunk should be self-contained — it should make sense without the other chunks.
3. Build the knowledge index. A structured JSON file with metadata:

// knowledge-base.json
[
  {
    "id": "refund-policy-001",
    "source_doc": "Company Policies — Refund and Cancellation",
    "section": "Refund Eligibility",
    "keywords": ["refund", "cancel", "money back", "billing", "charge"],
    "content": "ClearMetrics offers full refunds within 14 days of purchase for annual plans. Monthly plans can be cancelled at any time with no refund for the remaining period. To process a refund: 1. Customer submits request via support. 2. Support verifies the purchase date. 3. If within 14 days, process through Stripe dashboard. Partial refunds are handled case-by-case by the billing team."
  },
  {
    "id": "sso-setup-001",
    "source_doc": "IT Handbook — SSO Configuration",
    "section": "Setting Up SSO for a New Client",
    "keywords": ["sso", "saml", "okta", "azure", "single sign-on", "client onboarding"],
    "content": "To set up SSO for a new Enterprise client: 1. Confirm client is on Enterprise plan. 2. Navigate to Admin → Organizations → [Client Name] → Security. 3. Enable SAML SSO. 4. Provide the client with our SAML metadata URL: https://app.clearmetrics.io/saml/metadata. 5. Client provides their IdP metadata XML. 6. Upload the XML and test with a single user. 7. Enable 'Require SSO' only after successful test."
  }
  // ... 48 more chunks
]

Build the Q&A workflow: Slack slash command → search knowledge base → LLM generates answer with citations → reply in Slack.

┌─────────────┐    ┌──────────────┐    ┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│  Webhook     │───▶│ Code Node:   │───▶│ HTTP Req:    │───▶│ Code Node:   │───▶│ HTTP Req:    │
│  (Slack      │    │ Search docs  │    │ OpenAI API   │    │ Format       │    │ Slack API    │
│   /ask cmd)  │    │ (keyword     │    │ (answer with │    │ Slack reply  │    │ (post msg)   │
│              │    │  matching)   │    │  citations)  │    │              │    │              │
└─────────────┘    └──────────────┘    └──────────────┘    └──────────────┘    └──────────────┘

You are ClearMetrics' internal knowledge assistant. Team members ask you questions about company policies, processes, and product features.

RULES:
1. Answer ONLY from the documentation provided below. Never make up information.
2. If the answer is in the docs, respond clearly and cite the source document.
3. If the answer is NOT in the docs, say: "I don't have information about that in my knowledge base. You might want to ask [relevant team] or check [relevant system]."
4. Be concise — Slack messages should be scannable, not essays.
5. Use bullet points for multi-step processes.
6. Always end with the source: "📄 Source: [document name]"

DOCUMENTATION:
{{ $json.relevantDocs }}

If no relevant documents were found for this query, respond: "I couldn't find any documentation related to your question. Try rephrasing, or ask in #general for help from the team."

Post the response back to the user using Slack's response_url (provided in the slash command payload):

// Final HTTP Request node — respond to Slack
// Method: POST
// URL: {{ $('Webhook').first().json.body.response_url }}
// Body:
{
  "response_type": "in_channel",
  "text": "{{ $json.answer }}",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "💬 *{{ $('Webhook').first().json.body.user_name }}* asked: _{{ $('Webhook').first().json.body.text }}_"
      }
    },
    {
      "type": "divider"
    },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "{{ $json.answer }}"
      }
    }
  ]
}

Ensure the bot answers correctly when it should and says "I don't know" when it should. This is where most AI integrations fail — they hallucinate answers instead of admitting ignorance.

// In any Code node that parses LLM output:
try {
  const result = JSON.parse($input.first().json.choices[0].message.content);
  return [{ json: { ...result, status: 'success' } }];
} catch (e) {
  // LLM didn't return valid JSON — use raw text as fallback
  return [{ json: {
    score: 0,
    fit: 'error',
    summary: $input.first().json.choices[0].message.content,
    next_action: 'manual_review',
    status: 'parse_error',
    error: e.message
  }}];
}

• Working n8n workflows — 3 workflows, exported as JSON, with documentation comments in each node
• Knowledge base index — the docs-index.json and knowledge-base.json files, with instructions on how to add new documents
• HubSpot custom properties — 5 properties created and populated for test contacts
• Slack app — configured with slash command, installed in workspace
• Google Sheet — logging spreadsheet with columns defined and formula for monthly cost calculation
• Architecture diagram — visual map of all three workflows and how data flows between systems
• Runbook — step-by-step troubleshooting guide for common issues
• Loom walkthrough — 15-20 min video walking through each workflow, showing how to test, monitor, and update
• Prompt documentation — every system prompt stored in a shared doc with version history, so the team can tune prompts without editing n8n

CLEARMETRICS AI INTEGRATION — RUNBOOK

1. SYSTEM HEALTH CHECK (weekly)
   □ Open Google Sheet log — check for any "error" status rows
   □ Open n8n → Executions → filter by "Error" — investigate any failures
   □ Check OpenAI usage dashboard — verify costs are within expected range

2. COMMON ISSUES
   Issue: Lead enrichment stopped working
   → Check: Is the HubSpot workflow still active? (Automation → Workflows)
   → Check: Is the n8n webhook URL still correct?
   → Check: Is the OpenAI API key still valid? (platform.openai.com/api-keys)

   Issue: Slack bot not responding
   → Check: Is the n8n workflow active?
   → Check: Is the Slack app still installed? (api.slack.com/apps)
   → Check: Does /ask show an error in Slack? → Check n8n execution log

   Issue: Ticket triage classifying wrong category
   → Review recent tickets in the log sheet
   → Adjust the system prompt categories or add examples
   → Test with 5 sample tickets after changes

3. UPDATING THE KNOWLEDGE BASE
   → Add new doc: Create a new entry in knowledge-base.json
   → Include: id, source_doc name, section, keywords, content
   → Test: Ask the bot a question the new doc should answer
   → Verify: Bot cites the new document correctly

4. MONTHLY COST CHECK
   → OpenAI: platform.openai.com/usage → current month → compare to estimate
   → n8n: Check execution count → compare to plan limits
   → Expected: ~$5-10/mo OpenAI, ~$24/mo n8n cloud

5. ESCALATION
   For issues you can't resolve: [Your name] — [your email]
   Response time: Within 24 hours on business days

After this project, your Upwork profile should highlight:

— End of AI Integration Module —