Every Monday morning, someone on a marketing team sits down and spends 90 minutes pulling together last week’s numbers, skimming newsletters they didn’t have time to read, and writing a summary email nobody asked for but everyone expects. At Choco Media, we got tired of that loop and built a marketing automation workflow that handles the whole thing — data pull, news scan, write-up, and delivery — without anyone touching it. This post walks through exactly how we set it up, what tools we used, and where we kept humans in the loop.
This is aimed at small to mid-size marketing teams — two to ten people — who are drowning in information but short on time to synthesize it. You don’t need an engineering background. If you’ve used Zapier or Make before, you’re ready. If not, we’ll explain enough to get started.
What you’ll leave with: a working blueprint for an automated digest, tool recommendations with real costs, the prompts we use to keep the output feeling like it came from a person, and the three places where automation still fails without a human sanity check.
Why a marketing digest matters (and why most teams don’t have one)
A weekly marketing digest does a deceptively simple job: it turns noise into signal. Paid media numbers, organic traffic shifts, email open rates, competitor moves, industry news — all of it arrives in fragments across ten different tools. The digest forces a synthesis. Teams that do it consistently make better decisions; teams that skip it tend to react to whatever screamed loudest that week.
The reason most teams don’t have one isn’t laziness. It’s that producing it manually is genuinely tedious. You log into Google Analytics, then into Meta Ads Manager, then into your email platform, then into a Google Sheet someone set up two years ago. You copy numbers, you write a paragraph, you send it. It takes time that feels like it should be automated — because it should be.
- Manual digests average 60–120 minutes per week per person
- Consistency drops off after 3–4 weeks when the team gets busy
- By the time the digest lands, half the data is 5–7 days stale
- No institutional record forms — findings live in inboxes and get lost
The automated version solves all four. It runs whether anyone remembers or not, it pulls data in real time (or close to it), and it stores every digest in one place.
Choosing your automation platform: n8n vs Make vs Zapier
Three tools dominate here, and they suit different teams.
n8n
n8n is our recommendation for teams that want full control and are comfortable with a bit of setup. It’s open-source, can run self-hosted (free) or on n8n Cloud (from ~€20/month), and handles complex multi-step workflows without the operation-count anxiety you get with other tools. Its HTTP Request node makes it easy to pull from any API. The downside: the UI is less polished and the learning curve is steeper than Make or Zapier.
Make (formerly Integromat)
Make sits in the middle — more powerful than Zapier, friendlier than n8n. The free tier covers 1,000 operations/month, which is enough to run a weekly digest. Paid plans start at €9/month. Make’s data transformer module handles JSON parsing well, which matters when you’re pulling from ad platforms. This is what we’d recommend for a first build if you don’t have a developer handy.
Zapier
Zapier is the easiest to start with, but costs add up quickly at scale (from $20/month for multi-step zaps). For a weekly digest hitting several APIs, you’ll hit operation limits unless you’re on a paid plan. Use Zapier if your team already has it and you want the fastest path to a working prototype.
- n8n: best control, cheapest at scale, steepest setup
- Make: best balance of power and usability for most teams
- Zapier: fastest start, most expensive as complexity grows
Step 1 — Define what your digest actually covers
Before you build anything, write down the five to eight data points your team genuinely cares about every week. Be specific. “Marketing performance” is not a data point. “Meta Ads spend and cost-per-lead vs last week” is.
In client work we’ve found that digests get ignored when they contain too much. Thirty metrics sounds thorough; it reads like a spreadsheet dump. The digests people actually read cover fewer things with more context — not just the number, but whether it moved and why.
- Paid media: spend, CPL or ROAS, top creative by spend
- Organic: sessions, top landing page, any ranking movement
- Email: send volume, open rate, click rate, unsubscribes
- Pipeline (if B2B): leads generated, meetings booked
- One industry headline worth noting
That’s five categories. For most small teams, that’s the right scope. You can always add more once the workflow is stable.
The worst automated digest we ever saw pulled 47 metrics into a 2,000-word email that nobody read past the first paragraph. Start with what fits on a phone screen.
Step 2 — Connect your data sources
This is where most of the setup time goes. Each data source requires authentication, and every platform has its own quirks. Here’s what we connect and how.
Google Analytics 4
GA4 has a proper API (the Data API v1). You’ll create a service account in Google Cloud Console, download the JSON key, and authenticate via OAuth in your automation tool. The API lets you pull sessions, users, conversions, and top pages by time period. Make has a native GA4 module; in n8n you’ll use the HTTP Request node with the API directly.
Meta Ads
The Meta Marketing API requires a System User and an access token with ads_read permission. Once connected, you can pull spend, impressions, CPM, CPL, and creative-level performance. The API is well-documented but the auth setup is the most friction-heavy part of this entire build — budget 30–60 minutes the first time.
Google Ads
Google Ads API access requires a developer token (apply through your MCC account) and OAuth. For weekly digests, the most useful fields are spend, conversions, CPC, and top campaigns. If the API setup feels heavy, Google Sheets connected to a Looker Studio export is a reasonable fallback.
Email platform
Klaviyo, Mailchimp, and most major ESPs have REST APIs. You’re typically pulling last week’s campaign metrics: sends, opens, clicks, unsubscribes. This is usually the simplest API connection in the stack.
- Start with two data sources, get the digest working, then add more
- Use environment variables to store API keys — never hardcode them
- Test each data pull in isolation before wiring it into the full flow
Step 3 — Structure the automation flow
The workflow has four stages: trigger, data collection, AI write-up, and delivery. Here’s how they connect.
Trigger
Set a cron trigger for Monday at 07:00 your local time. The digest should be ready before the team starts their week. In n8n, this is a Schedule Trigger node. In Make, it’s a Scheduler module.
Data collection
Run your API calls in parallel where possible — GA4, Meta, and email can all pull simultaneously. Set each to return the current week vs. the prior week so you have comparison data. Store each result as a named variable or JSON object. This stage should take 10–30 seconds to execute.
AI write-up
This is where it gets interesting. You pass the structured data to an LLM (we use Claude or GPT-4o depending on the client’s stack) with a prompt that tells it exactly how to write the digest. More on the prompt structure in the next section.
Delivery
Send the output to Slack (a dedicated #weekly-digest channel works well), to email via your ESP, or both. We also write a copy to a Notion database so there’s a searchable archive. Notion’s API is straightforward for this — one record per week with the digest content as a rich text field.
Our AI automation service covers exactly this kind of workflow build for clients who want it done rather than DIYed.
Step 4 — Write a prompt that produces consistent output
The prompt is the hardest part to get right, and also the part most tutorials skip. A vague prompt produces vague output. A prompt that specifies voice, structure, and constraints produces something that reads like a person wrote it.
Here is the prompt structure we use:
- Role: “You are a concise, direct marketing analyst writing a weekly digest for a small team.”
- Tone constraints: “No bullet dumps. Every metric gets one sentence of context. Use plain language. No corporate filler.”
- Structure: “Write three sections: Paid Media, Organic, Email. Each section: one headline, two to three sentences, one sentence on what to watch next week.”
- Data block: Pass the structured JSON from your data collection stage inline.
- Length: “Maximum 350 words total.”
The most important constraint is length. Short digests get read. Long ones get skimmed or ignored. 350 words fits in a Slack message, renders well on mobile, and takes under two minutes to read.
Test the prompt with five weeks of historical data before you run it live. Look for hallucinations (numbers the model invented), passive voice overload, and sections where it hedged instead of saying something direct.
Step 5 — The human checkpoints you shouldn’t skip
Automation handles the mechanics. It does not handle judgment. In our experience, three things still need a human eye before the digest goes out.
Anomaly validation
If spend jumped 300% week-over-week, the model will report it — but it won’t know whether that was intentional (a campaign launch) or a tracking error. Build a simple anomaly flag: if any metric moves more than 50% week-over-week, route the draft to a human for review before delivery.
News and context
Automated digests are good at numbers and weak at context. A traffic drop that correlates with a public holiday, a competitor announcement, or a platform algorithm change — the model won’t know unless you tell it. The “one industry headline” section works best when a human adds it manually in 30 seconds before send.
Quarterly calibration
Every three months, read back through the digest archive and ask whether you’re still tracking the right things. Business priorities shift. A metric that mattered in January may be irrelevant by April. The workflow itself doesn’t know this — you do.
This ties directly into how we think about the broader question of AI-assisted content and reporting: automation handles volume and consistency; humans handle judgment and nuance.
What this looks like in practice
For a client running Meta Ads and Google SEO with a four-person team, here’s what the final stack looks like: n8n Cloud (€20/month) triggers every Monday at 07:00, pulls GA4 and Meta data via their respective APIs, passes the structured data to Claude via the Anthropic API (~€0.03 per run), formats the output, and posts to a Slack channel. Total setup time was about six hours. Weekly maintenance: zero. The team gets a clean, contextual digest in their Slack before they sit down for standup.
- Setup cost: 6–10 hours of configuration + API setup
- Running cost: €20–30/month depending on platform and API usage
- Time saved: 60–90 minutes per week per team
- Consistency: 100% — it runs whether anyone remembers or not
We’ve also built versions that include a competitive intelligence module — scraping a competitor’s published ad library or blog for notable moves — but that adds complexity and is worth a separate post.
Getting started: the 30-minute first build
Don’t try to automate everything at once. The fastest path to a working digest is this:
- Sign up for Make (free tier)
- Connect one data source — Google Sheets with manually pasted weekly numbers if APIs feel like too much for a first pass
- Add an OpenAI or Claude module with a tight prompt
- Send the output to your own email
- Run it for two weeks, read the output critically, refine the prompt
- Only then add real API connections and expand the scope
The goal of the first build isn’t perfection. It’s proving that the output is worth automating. Once you’ve read three digests and found them useful, you’ll have enough motivation to invest in the full build.
For teams who want this set up without the DIY cycle, our AI automation service covers the full build — data connections, prompt engineering, delivery setup, and ongoing calibration. If you’re not sure where to start, get in touch and we’ll walk through what makes sense for your stack.