Build a QBR Booked → Notion Checklist + Team Prep Emails Workflow with n8n
A Quarterly Business Review is only as good as the prep that goes into it. Yet the hour after a QBR gets booked is where most teams quietly drop the ball: the calendar invite lands, everyone assumes s
A Quarterly Business Review is only as good as the prep that goes into it. Yet the hour after a QBR gets booked is where most teams quietly drop the ball: the calendar invite lands, everyone assumes someone else is building the deck, pulling the usage data, and briefing the account owner — and then the meeting arrives half-prepared. The client notices. This article shows you how to build an n8n workflow that fires the moment a QBR is booked in Calendly and automatically spins up a Notion prep checklist, a client agenda email, an internal team brief, and a Slack alert — so prep starts itself instead of waiting on a human to remember.
The problem: booking a QBR is not the same as being ready for one
When a customer success manager books a QBR, a chain of small tasks should immediately begin. Someone needs to assemble the account health snapshot. Someone needs to draft an agenda and send it to the client so the meeting has a shared shape. The AE, the product lead, and the CSM need a heads-up with context. And a Notion page needs to exist as the single source of truth for the meeting.
In practice, none of this is triggered by the booking event itself. It's triggered by whoever happens to look at their calendar in time. That gap — between "the meeting is on the calendar" and "the team is actually prepared" — is where accounts churn quietly. A QBR that feels improvised signals that you don't have your arms around the relationship, and that's the exact opposite of what a renewal conversation needs to project. The failure mode isn't dramatic; it's just a meeting where nobody pulled the numbers and the client fills the silence with their own doubts.
The root cause is that prep is manual and event-blind. The booking happens in one tool (Calendly), the checklist lives in another (Notion), the comms happen in email and Slack, and no thread connects them. Humans are the integration layer, and humans forget.
The solution: let the booking event orchestrate the prep
The fix is to treat the Calendly booking as a trigger that fans out into four parallel outcomes, all before the meeting. n8n is the ideal orchestrator here because it speaks natively to Calendly, Notion, Gmail/SMTP, and Slack, and it lets you run those branches concurrently from a single event without writing glue code.
Here's the shape of the automation. A QBR gets booked in Calendly → n8n receives the event → it creates a Notion page from a prep-checklist template, pre-populated with the account name and meeting date → it sends the client a polished agenda email → it posts an internal team brief (email or Slack) with the account context and the link to the Notion page → and it drops a Slack alert into the CS channel so the whole team knows the clock has started. One event, four assets, zero manual steps. The account owner opens the Notion page and finds prep already scaffolded instead of a blank canvas.
Step-by-step: building the workflow in n8n
Below is the node-by-node build. The whole thing is a single workflow with one trigger and four downstream branches.
1. Calendly Trigger node. Use the native Calendly Trigger node and subscribe to the invitee.created event. To scope it to QBRs only, either create a dedicated Calendly event type ("Quarterly Business Review") and point the trigger at it, or add an IF node right after the trigger that checks {{$json.payload.event_type.name}} contains "QBR". The trigger payload gives you the invitee name, email, scheduled start time, and any answers to booking questions — capture the account name from a custom question if you can.
2. Set node to normalize your data. Immediately after the trigger, add a Set (Edit Fields) node to map the messy payload into clean variables: account_name, client_email, meeting_date (format it with {{ $json.payload.scheduled_event.start_time.toDateTime().format('cccc, LLL d') }}), and csm_name. Every downstream node reads from this Set node, so if Calendly changes its payload you only fix it in one place.
3. Notion node — create the checklist page. Add a Notion node, resource Database Page, operation Create. Point it at a "QBR Prep" database and set the title to {{ $json.account_name }} — QBR {{ $json.meeting_date }}. Populate properties like Owner, Client, and Meeting Date, then use the node's block-append capability (or a follow-up Notion → Append Block node) to write the checklist items as to-do blocks: pull usage/health data, review open support tickets, confirm renewal date, prepare 3 wins and 1 risk, draft next-quarter goals. Capture the returned page URL — you'll reuse it in the team brief.
4. Gmail / Send Email node — client agenda. Add a Gmail node (or Send Email via SMTP), operation Send. To: {{ $json.client_email }}. Subject: Agenda for our QBR on {{ $json.meeting_date }}. Body is an HTML template that frames the meeting: what you'll cover (results this quarter, roadmap, goals for next quarter), and a one-line ask for anything they want added. Sending the agenda ahead of time is what turns a status update into a strategic conversation.
5. Team brief + Slack alert. Branch a second email (or a Slack node, operation Send Message) to your internal channel. Include the account name, meeting date, the CSM, and — critically — the Notion page URL from step 3 so everyone lands on the same prep doc. Add a final Slack node posting a short alert to your #customer-success channel: 📅 QBR booked: {{ $json.account_name }} on {{ $json.meeting_date }}. Prep checklist → {{ $json.notion_url }}.
6. Wire the branches in parallel. Connect the Set node's output to the Notion node, and connect the Notion node's output onward to the email and Slack nodes so the brief can include the page URL. If you don't need the URL in a given branch, connect it directly off the Set node so it runs immediately. Add a No Operation or a final Merge node if you want a single clean endpoint for logging.
The payoff: prep that runs itself
Once this is live, the value compounds every quarter. The obvious win is time — you reclaim the 20–30 minutes of setup per QBR that used to be spread across three people and two tools. But the real return is consistency. Every QBR now starts from the same checklist, so junior CSMs prep like senior ones and nothing gets skipped under pressure.
The client-facing agenda email also lifts the meeting quality on its own. Clients arrive knowing what will be discussed, which means they show up with their own questions and decisions instead of passively receiving a report. And because the Notion page is created the instant the meeting is booked, there's a durable record of prep and follow-up for every account — searchable, linkable, and audit-ready when a deal goes to renewal. Multiply that across a portfolio of accounts and you've turned QBR prep from a recurring scramble into infrastructure.
Common pitfalls (and how to avoid them)
Firing on every Calendly event. The invitee.created webhook fires for all your event types, not just QBRs. Without the IF-node filter or a dedicated event type, you'll generate Notion pages for every discovery call and demo. Gate it early.
Handling reschedules and cancellations. Calendly also emits invitee.canceled. If someone reschedules, you can get a cancel plus a new create — which means a duplicate Notion page. Add a second trigger branch for the cancel event that archives or flags the corresponding Notion page, and consider a lookup step that checks for an existing page before creating a new one.
Timezone drift on the meeting date. Calendly returns UTC timestamps. If you format them without converting to the account's timezone, the client agenda can show the wrong day. Use the invitee's timezone from the payload (payload.invitee.timezone) in your date formatting expression.
Notion API rate limits and property mismatches. The Notion node fails silently-ish if a property name in your database doesn't exactly match what the node sends, or if a select option doesn't exist yet. Build the database schema first, match names exactly, and turn on Continue On Fail for the Notion node with an error branch that pings Slack so a failure never blocks the client email.
No retry on transient failures. Email and Slack APIs occasionally hiccup. Set each external node's Retry On Fail to 2–3 attempts with a short wait, so a momentary 500 doesn't leave your team un-briefed.
Ja construimos isso pra voce
Nao comece do zero. O QBR Booked → Notion Checklist + Team Prep Emails e um workflow n8n pronto para instalar — conecta suas ferramentas em minutos, sem codigo.
Instalar por $29 →
