Ship a Zero-Touch Client Proof Digest (Gmail + Make + Notion) in 90 Minutes Guide

You're installing an "operational visibility" layer. Every Tuesday morning (or the client's preferred day/time), your client gets:

• A 120–180 word email with four sections: Shipped, In Progress, Blockers, Next Week (max five bullets each).
• A Notion page in their client portal with the same sections plus source links to emails/tasks.
• Optional: a short Slack post to their shared channel (top 5 bullets) and an on‑demand PDF for procurement.

Defaults that work:

• Schedule: weekly, client-local timezone, 9:00 AM local.
• Cost: ≈ $0.12/run (tokens ≈ $0.08 + orchestration ≈ $0.04). PDFs only on demand (~$0.03/file).
• Packaging: Sell as "Operational Visibility" add‑on at $200/month per client.
• Success metric: ≥ 60% email open, ≥ 35–45% click to the Notion page within the first month.

Required components (Make equivalents shown; Zapier/n8n in the Alternatives section):

1. Source(s)

• Gmail (best: client-labeled threads) OR your helpdesk (Help Scout/Zendesk) OR IMAP mailbox.

1. Orchestrator

• Make scenario on a weekly schedule.

1. LLM summarizer

• OpenAI or Gemini module in Make.

1. Client portal

• Notion workspace with a database for digests and a page template.

1. Optional outputs

• Slack (shared channel) and HTML→PDF (only if requested by the client).

Notion setup (do this once):

• Database: Client Portal — properties:
• Name (title)
• Client (select or relation)
• Type (status or select: Weekly Digest)
• Week (date or text like "Mar 30–Apr 5, 2026")
• Inputs processed (number)
• Tasks completed (number)
• Portal URL (url)
• Page template blocks (four callouts):
• ✅ Shipped
• 🚧 In Progress
• ⚠️ Blockers
• 📅 Next Week

Logging database ("Digests Sent"):

• Client (relation)
• Sent at (date/time)
• Scenario run ID (text)
• Email message ID (text)
• Notion page URL (url)
• Email opens (number, optional)
• Link clicks (number, optional)

Create a new scenario in Make.

1. Trigger — schedule

• Module: Scheduler → Every week.
• Day/time: client's local day/time (e.g., Tuesday 09:00).
• Timezone: pick the client's timezone from the dropdown. Test around daylight saving changes.

1. Collect activity — Gmail

• Module: Gmail v4 → Search emails.
• Filter type: Gmail filter.
• Query (example; edit the label):

```
label:ClientName newer_than:7d -category:promotions
```

• Limit: 100 (raise only if you routinely miss key threads).
• Content format: Full.
• Include HTML body: enabled.

Notes and variants:

• Help Scout: use native module or HTTP; mind rate limits (writes count double). Pull last 7 days per mailbox/conversation.
• Zendesk: list recent tickets/comments last 7 days; respect plan rpm limits.
• IMAP: Make's Email (IMAP) works for non‑Gmail. Keep the weekly window narrow and batch if volume is high.

1. Optional: add other sources

• If you maintain a Notion task board, pull “Done”/“Updated in last 7 days” items and append to the input array for the LLM. Keep total inputs sane (< 500 emails/items) to control latency and token cost.

Goal: four concise sections with links back to source items. Keep the model deterministic and short.

Module: OpenAI (or Gemini) → Text generation

• Max tokens: 500
• Temperature: 0.2–0.4
• System style (prepend once):

```
You are a technical consultant writing a quick weekly status update. No corporate speak. Be specific and client-facing.
```

User prompt (pass the collected emails/tasks as {{inputs}} and include their IDs/URLs):

```
Analyze these emails and tasks from the past 7 days. Output STRICT JSON with four arrays: shippeditems, inprogress, blockers, next_week.
Rules:

• Max 5 items per array.
• Each item is a single sentence and MUST include a source_id that I can map to an email/task URL.
• Focus on client-visible outcomes (savings, fixes, integrations shipped), not internal process.
• If no items for a section, output an empty array.

Inputs:
{{inputs}}
```

Expected JSON shape:

```
{
"shippeditems": [{"text": "Fixed Stripe webhook retries; eliminated manual reconciliation.", "sourceid": "gmail_18d9"}],
"inprogress": [{"text": "HubSpot ticket sync mapping staged for UAT.", "sourceid": "task_442"}],
"blockers": [{"text": "API rate limit—awaiting elevated quota from vendor.", "sourceid": "gmail1902"}],
"nextweek": [{"text": "Deploy inventory sync to production and monitor for 48h.", "sourceid": "task_455"}]
}
```

Guardrails that matter:

• Always include a source_id per bullet. You’ll map it to a link in Notion.
• Enforce the 5‑item cap; clients skim.
• If input volume is huge, chunk by thread or sender, summarize per chunk, then re‑summarize the chunk summaries (same schema).

Create a Notion page with your digest and ship it via email (and optionally Slack).

1. Notion — Create page

• Target: Client Portal database.
• Title: "[Client] — Weekly Digest — [Week]" (e.g., "Acme — Weekly Digest — Mar 30–Apr 5, 2026").
• Properties: set Client, Week, Inputs processed, Tasks completed.
• Content blocks (map arrays into callouts):
• ✅ Shipped → list up to 5 bullets, each linking to its source.
• 🚧 In Progress → bullets with source links.
• ⚠️ Blockers → bullets with source links.
• 📅 Next Week → bullets with source links (or internal task links).

Source links

• Emails: store the Gmail/IMAP ID alongside each item and render a mail link. For helpdesks, use their conversation/ticket URLs.

1. Email — send the digest

• Module: Send an email (Gmail or SMTP).
• Subject: "This week: [top shipped outcome] (+ link to full digest)".
• Body template (plain or simple HTML):

```
Hi [Client First],

Here’s what we accomplished this week:

Shipped

• [bullet 1]
• [bullet 2]

In Progress

• [bullet 1]

Blockers

• [bullet 1]

Next Week

• [bullet 1]

Full details in your portal → [Notion link]
– [Your Name]
```

1. Slack (optional)

• Post to the shared channel with the top 5 bullets across all sections + the Notion link. Keep under 1000 chars.

1. PDF (optional, on demand)

• Only generate if the client requires a file archive. Render the same four sections; attach to an email reply or upload to Notion.

Add durable proof and gain read/click visibility.

1. Write to "Digests Sent" in Notion

• Fields: Client, Sent at (now), Scenario run ID, Email message ID, Notion page URL.

1. Track opens/clicks

• If you send via Gmail, track clicks via the Notion link’s query params (e.g., add ?utmsource=digest&utmweek=2026-04-05&client=acme). Maintain a simple “Reads” rollup by week/client.

1. Human-in-the-loop (lightweight)

• If the Blockers array is non-empty, route the draft email to yourself first. Skim for tone and accuracy (30–60 seconds), then forward to the client.

1. Monthly pulse

• Create a Notion view grouped by Client → count of digests sent, average open rate, average click rate. Bring this chart to QBRs and renewals.

Harden the build where it typically breaks:

• Gmail auth expiry: personal @gmail.com accounts require re‑auth about every 6 months. Set a calendar reminder.
• Gmail search ceiling: the module returns up to 500 messages per search. Keep the 7‑day window; filter aggressively by label/sender.
• Notion API: ~3 requests/sec average. Add a 2s delay between clients if you loop through many.
• Notion modules: newer "Data Source ID" supersedes legacy "Database ID" in some modules; mixing versions can fail silently. Standardize on the new modules in Make.
• Timezones & DST: schedule in the client’s timezone and test a week that crosses DST.
• Token budget: cap LLM max tokens at ~500 and keep inputs compact. Use chunking if needed.
• Slack etiquette: post once per week to the shared channel. Avoid DM spam.
• PDF reliability: generate only on demand; treat failures as non-blocking (email + Notion are the primary surfaces).

If you don’t use Make, these swaps keep the pattern intact.

Zapier

• Accumulate: Digest by Zapier to collect notable events (or pull Gmail weekly with a search).
• Summarize: ChatGPT (OpenAI) or Google AI Studio (Gemini) step with the same prompt and JSON schema.
• Publish: Notion — Create Page, then Gmail — Send Email.
• Note: Operations cost is typically higher; keep steps tight.

n8n

• Trigger: Cron weekly.
• Source: Email IMAP node (or HTTP to Help Scout/Zendesk).
• Summarize: OpenAI (Responses API) or Google Gemini node with the same prompt and caps.
• Publish: Notion node to create a page; SMTP or Gmail node to send the email; Slack node optional.

HubSpot-first variant

• Sources: Tickets updated last 7 days and Conversations threads.
• Example pulls (pseudo):

```
GET /crm/v3/objects/tickets?limit=100&properties=subject,lastModifiedDate&propertiesWithHistory=status&archived=false
GET /conversations/v3/conversations/threads?limit=100&after=7d_ago
```

• Feed those records to the same LLM step; publish to Notion/email as above.

Batching for many clients

• Loop clients inside one scenario/workflow. For each client: set label/inbox, run the same steps, sleep 2s between clients to respect Notion limits. Expect ~70% fewer orchestration ops than one-scenario-per-client.

Run one dry pass first, then flip to automatic.

• Pick a single renewal‑risk client.
• Build the scenario with the defaults above; run it manually once.
• Fix any malformed links or mismatched IDs.
• Ship the first digest and watch for replies.
• Turn on the weekly schedule and add the Notion writeback.
• After 3 weeks, review opens/clicks and (if applicable) whether renewal risk decreased.

Positioning line you can paste in proposals:

```
Operational Visibility — You’ll never wonder what we’re working on. Every [day/time], you’ll see exactly what shipped, what’s in progress, and what’s coming next week — with links to the source.
```