Most automation projects don't start with a big vision. They start with someone saying, "This is taking way too long, and I know there has to be a better way." That's exactly how this engagement began. A 30-person professional services firm reached out because one of their senior account managers was spending most of Monday morning, every week, sending onboarding emails by hand. Eight hours a week, every week, on a task that should have been automatic.
They weren't complaining about the effort exactly. They were complaining about what that effort was costing them: inconsistent timing, inconsistent content, and a team member who could have been having actual conversations with clients instead of copying and pasting into Gmail.
The Problem
When a new client signed on, this firm sent 15 emails over the first 30 days of the relationship. Not a blanket newsletter. Fifteen individual, personalized emails: welcomes, introductions to team members, how-to guides for their software, check-ins at specific intervals, and a 30-day review prompt.
Each email had to be personalized with the client's name, company name, and the specific services they'd purchased. Each one had to go out at the right time relative to when they signed on. And every send had to be logged in HubSpot so the account team could see what had gone out and when.
The manual process worked, in the sense that the emails mostly went out. But "mostly" is the problem. When the account manager was out sick, emails got delayed or skipped. When two new clients came in the same week, things got missed. When a new team member tried to cover, the tone and content weren't consistent. The firm was delivering a slightly different onboarding experience to every single client, based entirely on who was working that day.
What We Built
The solution used three tools: Make.com as the automation backbone, HubSpot as the CRM where client records lived, and ActiveCampaign as the email platform where sequences would run.
The core logic was straightforward: when a client record in HubSpot gets marked "Active," Make detects that change and triggers a specific ActiveCampaign sequence for that contact. The sequence handles all 15 emails, spaced at the correct intervals, with the personalization variables pulled from HubSpot automatically. Name, company, services, account manager name: all of it flows through without anyone touching it.
We also built a lightweight intake form for the account managers. When they mark a client Active, they fill out a short form: any notes about the client's priorities, the specific services they signed up for, and whether the client has any unusual preferences or context. Those notes get pulled into the first email in the sequence, so it reads like someone actually wrote it for that client, because in a meaningful way, someone did.
The full build came to three Make scenarios, one intake form, and one ActiveCampaign sequence with 15 emails. Nothing exotic. Just well-connected tools doing exactly what they're designed to do.
The Timeline
Day one was scoping. We ran a two-hour call with the account manager and the firm's operations lead. We mapped every email in the sequence: what it said, when it went out, what needed to be personalized, and what "success" meant for each touchpoint. We documented every personalization variable and traced exactly how each one would flow from HubSpot into ActiveCampaign via Make. By the end of the call, we had a complete spec with no ambiguity.
Day two was the build. We constructed the three Make scenarios, set up the intake form, and built the ActiveCampaign sequence from scratch. Then we tested everything with sample data: a fictional "ACME Corp" client with every field filled in. We checked that every email rendered correctly, that the timing was right, and that HubSpot showed each send logged appropriately.
Day three was real-data testing and handoff. We tested with actual client data, which is where the edge cases showed up. Two of them mattered: clients with multiple contacts (the system needed to know which contact to send to when a company record had three people listed), and international clients in time zones where some of the timed sends would arrive at 2 a.m. We fixed both, added documentation that covered both scenarios, and then ran a 30-minute walkthrough with the account team so they understood exactly what was happening and how to manage exceptions.
The Results
The firm now spends zero hours per week on manual email sending. The sequence runs automatically for every new client without anyone initiating it, monitoring it, or following up on it.
Open rates on the onboarding sequence went up. The primary reason is timing: emails now go out at consistent, optimized times rather than whenever someone got around to sending them. The second reason is consistency: every client gets the same thoughtfully written sequence, not a version that varies based on how much time the account manager had that morning.
The account managers use Monday mornings differently now. Instead of sending emails, they're making calls, reviewing project status, and doing the work that actually requires a person. That shift in how their time gets used has had a measurable effect on the team's sense of what their job is actually about.
What This Kind of Build Usually Costs and Takes
Email onboarding automations in this range of complexity take two to four days depending on how many sequences are involved, how complex the personalization logic is, and how many edge cases exist in the client's data. This one came in at three days, which is typical.
One thing worth noting: this firm didn't have to buy any new software. Make, HubSpot, and ActiveCampaign were already in their stack. The entire project was a matter of connecting tools they were already paying for and configuring them to work together. That's a pattern we see often. The automation capability is already there. It just hasn't been wired up yet.
What This Is Really About
The most valuable thing we built wasn't a Make scenario or an ActiveCampaign sequence. It was a guarantee. Every new client this firm brings on now gets the same excellent, thoughtful, well-timed onboarding experience, regardless of how busy the team is, who's out sick, or whether it's a slow week or a sprint.
That consistency is what good automation actually delivers. It's not about replacing people. It's about making sure that the quality of the work doesn't depend on conditions that are outside anyone's control. When you build that kind of reliability into your client experience, it shows, and clients feel it even if they can't articulate why.