Key Takeaways
- Pick three integrations on day one, not ten. The teams that connect everything in week one end up with a coworker that touches no workflow well. The teams that connect three the right ones get a working runbook by week two.
- The dependency rule: integration #1 should be where the trigger lives, integration #2 where the data lives, integration #3 where the output goes. If two of your three are output channels, you have nothing to do.
- The default for most teams under 50 people: Slack (output), Stripe (data), HubSpot or Gmail (trigger). This stack covers revenue digests, customer triage, and meeting prep. It is enough.
- Sales-first teams need a CRM, ops-first teams need a finance tool, support-first teams need a ticketing tool. Pick the integration that matches your loudest weekly meeting.
- Skip the integrations that look impressive but produce no recurring value: Salesforce when you actually use HubSpot, Notion when your team writes in Slack canvases, Jira when you use Linear. Connect what your team actually uses, not what you wish they used.
- The fourth integration is a graduation reward. Add it after your first runbook hits Rung 4 (auto). Until then, depth beats breadth.
Twelve integrations on day one. Stripe, HubSpot, Notion, Slack, Linear, Pylon, Google Calendar, Gmail, Attio, GitHub, Apollo, Mixpanel. That was the list a founder of a 25-person SaaS team showed me last month for his Viktor rollout. He had a long view of what the team eventually wanted automated. The list was correct in two years and wrong on day one.
The mistake is connecting everything before you have a single working runbook. When the AI coworker has access to twelve tools but no defined workflow, it ends up doing nothing well. The team prompts it for one-off tasks, gets mediocre results, and concludes "the AI is not ready." The AI was ready. The setup was wrong.
This post is the decision tree for the first three integrations. Stage-by-stage defaults, the dependency rule, the integrations to skip on day one, and what to add fourth once your first runbook is stable. Use it the next time you are about to mass-connect everything.
The dependency rule
Every useful runbook has three roles. Trigger, data source, output. A weekly revenue digest triggers on a schedule (the schedule is the trigger), reads from Stripe and HubSpot (the data sources), and posts to Slack (the output). If your three integrations do not cover all three roles, you have a coworker that cannot run a single end-to-end workflow.
What goes wrong if all three are outputs
A team I talked to last quarter connected Slack, Microsoft Teams, and Gmail as their first three integrations. Logical: those are the three places they communicate. The problem: there was nothing to communicate about. No trigger, no data. The coworker could send messages but had nothing meaningful to say.
What goes wrong if all three are data sources
The opposite mistake. Stripe, HubSpot, and Notion. The coworker can read everything but cannot tell anyone about it. The team ended up using the AI as a glorified data-lookup tool: "Hey Viktor, what is our MRR right now?" That is chat. That is not a coworker. That is one of the patterns we cover in The 30-second rule for AI coworkers.
The right shape
| Role | Examples |
| Trigger | Schedule (cron), incoming Stripe webhook, new HubSpot deal, inbound email, calendar event |
| Data | Stripe, HubSpot, Salesforce, Pylon, Linear, Notion, Google Sheets, Mixpanel, PostHog |
| Output | Slack, Microsoft Teams, Gmail, Notion page update, CRM update, Linear ticket creation |
Pick one of each. Slack is almost always the output for early teams (under 100 people, Slack-native). The trigger is usually a schedule or a webhook. The data source is the tool where the answer to "what changed this week?" lives.
The default for most teams under 50 people
Three integrations cover roughly 80% of high-value runbooks for early teams.
Slack as output
Slack is the meeting room for under-50 companies. The Monday digest goes here. The Friday reconciliation goes here. The morning ticket triage goes here. The runbook that posts an internal message in Slack costs roughly zero attention to consume. Email asks for an action. Notion needs you to remember to open it. Slack is already where you are.
Stripe as the data spine
If your company makes money, Stripe (or a Stripe-equivalent: Recurly, Chargebee, Maxio) is the data spine. Most useful first runbooks ask a question that boils down to "what happened to revenue this week?" That answer lives in Stripe. Even if your CRM is the system of record for sales pipeline, Stripe is the system of record for what actually got paid.
HubSpot or Gmail as the trigger
This is the splittable one. If you have a sales motion (you talk to customers before they pay), HubSpot is the trigger. New deals, stage changes, won/lost are the events that matter. If you are mostly self-serve (customers sign up without a sales call), Gmail is the trigger. New customer emails, support requests, and partner outreach hit your inbox first.
Every Monday at 9 AM Warsaw, post in #revenue:- Current MRR from Stripe (last 7 days)
- Week-over-week delta (number and percent)
- Top 3 customers by ARR pulled from Stripe + HubSpot deal data
- Any deal over $10K closed-won in HubSpot last week
- Any churn event over $1K MRR with the cancellation reason
If MRR fell more than 5% WoW, ping me first and wait for review before posting to channel.
Format: Slack thread, dollar amounts rounded to thousands. ```
This three-integration combo (Slack + Stripe + HubSpot) runs the workflow above on day one. No fourth integration needed. The runbook compounds.
The decision by team type
The default works for most. For specialized teams, swap one integration to match the loudest weekly meeting.
Sales-first team
Slack (output), HubSpot or Salesforce (data), Gmail or Apollo (trigger).
The sales team's loudest meeting is the weekly pipeline review. The runbooks that pay back are pipeline hygiene (deals stale 14+ days), reconciliation (HubSpot closed-won vs Stripe charges), and meeting-prep aggregation. Stripe is useful but not first. HubSpot is the spine.
Ops or finance team
Slack (output), Stripe (data), Google Sheets or Notion (trigger via shared dashboard).
The ops team's loudest meeting is the Monday or Friday business review. The runbooks are revenue digests, runway forecasts, expense flagging. Stripe is the spine. The trigger is usually the schedule itself.
Support team
Slack (output), Pylon or Zendesk (data), schedule (trigger).
The support team's loudest meeting is the morning standup. The runbook is overnight ticket triage with P0/P1/P2 classification. The data tool is the source of truth for tickets; nothing else is needed on day one.
Engineering or product team
Slack (output), Linear or Jira (data), GitHub (trigger).
The eng team's loudest meeting is the weekly sprint review. The runbooks are PR summary digests, stale-ticket flagging, and roadmap reconciliation. Linear (or Jira) is the spine; GitHub events are the trigger.
What to skip on day one
The integrations that look impressive but produce no recurring value in the first month.
Salesforce when you actually use HubSpot
Connect the CRM your team writes into, not the one your investors expect to see. If your reps log calls in HubSpot, that is your CRM. The Salesforce connection is dead weight until someone actually uses it.
Notion when your team writes in Slack canvases
Same logic. Connect the tool with active activity. A Notion workspace with three lonely pages is not a useful data source. A Slack channel with daily activity is.
Jira when you use Linear
Linear has cleaner APIs, better webhook support, and your team probably picked it for a reason. Skip Jira until a customer-or-leadership force makes you connect it.
Mixpanel or Amplitude on day one
Product analytics integrations sound powerful and produce almost no useful runbooks in week one. The questions analytics tools answer (cohort retention, funnel conversion) are quarterly questions, not weekly ones. Add them in month two if a runbook actually needs them.
Every integration "in case we need it later"
Every integration is a permission scope your team has to approve and a maintenance surface. Add integrations when a runbook needs them, not before. Agents are most reliable when their tool surface is small and well-defined. The fewer tools, the cleaner the workflow.
When to add the fourth integration
The fourth integration is a graduation reward. Add it once your first runbook hits Rung 4 (the trust-ladder rung covered in The 30-second rule for AI coworkers) and runs without your review for two consecutive weeks.
Why graduation matters
Two consecutive weeks of clean runs proves three things: the runbook is shaped right, the team trusts the output, and the AI coworker is genuinely doing work instead of generating busy-work for the reviewer.
Adding a fourth integration before that point is how teams end up with five half-working runbooks instead of one clean one. Depth on the first three beats breadth across ten.
Common fourth integrations
The fourth slot usually goes to one of: a CRM you skipped on day one (Salesforce, Attio), a ticketing tool (Pylon, Zendesk, Intercom), an analytics tool (Mixpanel, PostHog, Amplitude), a calendar (Google Calendar) for meeting-prep workflows, or a code tool (GitHub) for engineering digests.
Pick whichever extends your strongest existing runbook. If your weekly revenue digest is solid, add a CRM to enrich the customer names. If your morning ticket triage is solid, add a Stripe connection to auto-classify by customer tier.
A worked example
A 25-person SaaS founder I worked with last quarter connected Slack, Stripe, and HubSpot on day one. By end of week one, the Monday revenue digest was running at Rung 1 (read-only, posting drafts for her review). By end of week three, it was at Rung 4 (auto, posting without review).
The expansion sequence
She added a fourth integration in week four: Pylon, for support tickets. The runbook she wrote next was the morning ticket triage. By week six it was running at Rung 4. Then she added a fifth: Google Calendar. The meeting-prep aggregation runbook came online in week eight.
Total elapsed time from "what should we automate?" to "three runbooks running on auto, five integrations connected, four hours a week back": 60 days. The slow start (three integrations, one runbook) was what made the fast finish possible.
This pattern matches what we have seen across hundreds of customer deployments: the teams that incrementally expand automation surface have measurably fewer rollback events than the teams that connect everything in week one.
Frequently Asked Questions
What if I do not use any of the tools you listed?
The category matters more than the specific tool. Output (where your team reads internal messages), data (where your business data lives), trigger (what causes the runbook to run). Map your tools to those three roles and the framework holds.
Do I need a CRM to start?
No. If you are pre-revenue or self-serve, your CRM is replaced by your inbox or your product analytics. Connect those instead. CRM is the right answer once you have a sales motion with at least one full-time seller.
Should I connect Slack and Microsoft Teams both?
No. Pick the one your team actually communicates in and ignore the other until a customer or stakeholder demands cross-posting. Most teams have a clear answer here even if they think they do not.
How do I know which is my "loudest weekly meeting"?
The one where the most senior person is most engaged. The one where decisions actually get made. The one where if it got cancelled, someone would notice. That is the meeting your first runbook should support, and the data tool feeding that meeting is your day-one data integration.
What if my team uses 20 tools?
Most do. The question is not "which 20 tools do you use?" but "which 3 do you check daily?" Daily-check tools are integration candidates. Weekly-check tools wait for slot four or five. Monthly-check tools probably never need to be connected.
How long should I wait before adding integration #4?
Two consecutive weeks of your first runbook running without your review. If that takes one month, fine. If it takes three months, that is also fine. Time is not the gate; runbook stability is.
What about specialized vertical tools like Toast, Procore, or Clio?
If they are your daily-check tool, they are integration #1 or #2 by definition. Most niche-vertical SaaS now has at least a basic API or a Zapier/Make connector that an AI coworker can route through. Connect what your team actually uses, not what's "common."
Closing thought
The integration count is not the metric. The runbook count is. A team with three integrations and two stable runbooks is ahead of a team with twelve integrations and zero stable runbooks. Always.
Pick three. Run them at Rung 1 for a week, Rung 2 for a week, Rung 4 by week three if the workflow is stable. Add the fourth only after the first runbook has earned it. Depth before breadth, every time.
For the runbook template, see How to write a runbook for your AI coworker. For the framework on what is worth a runbook, see The 30-second rule for AI coworkers. For an operator's view of the first week, see The first 7 days with an AI coworker.
