Most small and mid-size businesses do not need custom software. They need the software they already pay for to talk to each other.
A lead fills a form on the website. Someone copies the name into the CRM. Another person creates a draft invoice in QuickBooks. A third posts a note in Slack so the account manager sees it. Four tools. Three manual hand-offs. One process that breaks when someone is on vacation.
We fix this by mapping the existing workflow, then linking the apps with an automation platform, Zapier, Make, or n8n, so the data moves without human copy-paste. The Blueprint stage takes one to two weeks. The Pilot runs for two to four weeks on your actual data, next to your team. If it works, we roll it out. If it doesn't, you learned something cheap.
Start with the manual map
Before we touch an automation platform, we write down every step a human currently takes. Not the ideal process. The real one.
Open a blank document. List the trigger: "New row in Google Sheets from Typeform." Then list every click: "Open Gmail, search for email, copy address, open HubSpot, create contact, paste address, set lifecycle stage to Lead, assign to owner, click Save." Note the exceptions: "If company exists, update instead of create." "If email bounces, tag as bad and notify sales in Slack."
This map is the Blueprint. It usually takes us a week or two to produce because the real process lives in heads, not docs. We interview the people who do the work. We watch them run through a few records. We count the clicks and the wait times.
The map tells us three things: which steps are pure data movement (candidates for automation), which need human judgment (stay manual), and where the failure points hide (duplicate contacts, missing required fields, rate limits).
Choose the platform for the job
We work with three main platforms. Each fits a different shape of problem.
Zapier is the easiest starting point. It supports the widest list of apps, Gmail, Outlook, Google Sheets, Excel, HubSpot, Salesforce, Shopify, QuickBooks, Xero, Slack, Microsoft Teams, Airtable, Notion, and most tools with a public API. The interface is linear: trigger, action, action. It handles simple branching and filters. It runs in the cloud. Pricing scales with task volume. We use Zapier when the workflow is a straight line or a shallow tree, the team wants to maintain it themselves, and the app list is standard.
Make (formerly Integromat) adds a visual scenario builder with routers, iterators, and aggregators. You can loop through line items on an invoice, transform arrays, and handle complex error routes in one scenario. It still runs in the cloud. We reach for Make when the logic gets nested, for example, "for each order line, check inventory in Airtable, if low then create purchase order in QuickBooks and post to Slack." The learning curve is steeper, but the ceiling is higher.
n8n is the option when data cannot leave your infrastructure or when you need custom nodes. It can run on your own server (Docker, Kubernetes, even a VM). You can write JavaScript or Python inside a function node. You can add private APIs that have no public connector. We use n8n for private AI deployments, for workflows that touch on-prem databases, or when the compliance requirement says "data stays here." It demands more DevOps ownership. The trade-off is control.
We do not marry a platform. A pilot might start in Zapier and move to Make when the logic outgrows it. Or start in n8n because the security review demands it. The Blueprint tells us where to begin.
Build the pilot on real data
A pilot is not a demo on test data. We build one working automation and run it next to your team on your production data for two to four weeks.
Take the lead-handling example. The trigger: new form submission in Typeform. Actions: search HubSpot for existing contact by email. If found, update; if not, create. Enrich with Clearbit or Apollo if the plan includes it. Assign owner based on territory spreadsheet in Google Sheets. Create follow-up task due in two days. Post summary to #sales-leads in Slack with a link to the contact record.
We deploy this in the chosen platform. We turn on logging. We give the team a simple dashboard: runs succeeded, runs failed, last run time, sample payload. We set up alerts on failures, email to the ops lead, Slack message to the channel.
The team keeps doing the manual process in parallel for the first week. They compare outputs. They flag mismatches. We adjust field mappings, add missing filters, handle the edge case where the form allows a free-text country but HubSpot expects a picklist value.
By week two, the automation handles the happy path cleanly. By week three, it handles the known exceptions. By week four, the team trusts it enough to stop the manual shadow run.
That is the pilot gate: does the team trust it? If yes, we plan rollout. If no, we either iterate or kill it. Either way, the cost was bounded.
Common patterns we see again and again
CRM lead capture and follow-up
Form or inbound email → deduplicate in CRM → enrich → score → assign → create task → notify owner. The variation is in the enrichment source (Clearbit, Apollo, built-in CRM data) and the scoring rules (company size, role, page views). The automation platform handles the plumbing; the CRM holds the logic.
Invoice payment reminders
QuickBooks or Xero invoice created → wait 30 days → if status unpaid → send email from shared inbox → log activity in CRM → create task for AR clerk → if still unpaid at 45 days → escalate to manager in Slack. The wait steps are native in all three platforms. The email send uses Gmail or Outlook OAuth. The escalation is a Slack webhook.
Support inbox triage
New email in shared inbox → AI reads subject and body → classifies: billing, technical, spam, other → applies label in Gmail → routes to correct Slack channel or creates ticket in Zendesk/Intercom → drafts reply using template + account context from CRM → human reviews and sends. The AI step can run in a private n8n deployment calling a local model, or via an API call to OpenAI/Anthropic from Zapier or Make. The key is the human review gate before send.
E-commerce order operations
Shopify order paid → check inventory in Airtable/Google Sheets → if available → create fulfillment in ShipStation → send tracking email → update order note in Shopify → post to #fulfillment Slack. If not available → create backorder record → notify purchasing → hold fulfillment. The inventory check is a lookup step. The branching is a router.
Reporting and dashboard refresh
Scheduled trigger (daily 6 AM) → pull data from HubSpot deals, QuickBooks invoices, Google Ads spend, Shopify sales → transform in Make's data tools or n8n function node → write to Google Sheets or BigQuery → refresh Looker Studio / Power BI dashboard → email snapshot to leadership. No manual CSV downloads. No forgotten refreshes.
Client onboarding
Deal marked Closed Won in HubSpot → create project in Asana/ClickUp from template → create folder in Google Drive → send welcome email from account manager's Gmail → create Stripe subscription or QuickBooks recurring invoice → post kickoff reminder to #onboarding Slack. The template project carries task assignments and due dates relative to the trigger date.
Where AI fits in the plumbing
AI is not the automation. It is a step inside the automation.
We use AI for: reading unstructured email and extracting structured fields (invoice number, due date, dispute reason); classifying incoming requests; drafting replies that a human approves; summarizing long threads before escalation; converting a PDF quote into a CRM opportunity with line items.
The AI step takes an input (email body, PDF bytes, thread history) and returns JSON (classification, extracted fields, draft text). The automation platform passes that JSON to the next step, create record, update field, post message.
If the data sensitivity requires it, we run the AI model on your server via n8n. The prompt and the data never leave your network. The automation platform still orchestrates the flow; the AI node is just a local HTTP call.
Human oversight stays in the loop
We do not build fully autonomous agents that act without review. The automations we ship have explicit approval gates.
A drafted reply sits in a Gmail draft folder. A human opens it, edits, sends. A proposed CRM merge shows as a task. A human confirms. A flagged invoice posts to Slack with buttons: "Approve payment hold" / "Mark paid" / "Escalate." A human clicks.
This keeps the team in control. It also builds trust. When the automation handles the lookup, the formatting, the routing, and the human makes the judgment call, the error rate drops and the team actually uses the system.
Training and documentation come with the build
A pilot that nobody can maintain is a liability. We document every scenario: trigger, connections used, field mappings, error routes, how to test, how to disable. We record a 15-minute walkthrough video. We run a live training session with the people who will own it.
We also set up monitoring. Failed run alerts go to a distribution list, not a single person. Monthly health checks: task volume trends, error rate, API version changes, new app features that could simplify the flow.
Rollout and care is the third phase. It means we stay available to adjust when HubSpot changes a property type, when Shopify adds a webhook, when the team wants to add a new branch for a new product line.
What to expect in the first conversation
If you book the free 30-minute call, we will ask:
- Which apps are in the mix today?
- Which process hurts most, volume, errors, speed, or frustration?
- Who owns the process and who executes it?
- Where does the data live, and are there constraints on where it can go?
- What does "good enough" look like for a pilot?
We do not need a requirements document. We need a willing process owner and access to the apps (or a sandbox). The Blueprint drafter on our site lets you sketch the flow in plain English before we talk. What you type there is not stored unless you send it to us.
The pattern that works
Map the manual work. Pick the platform that fits the logic and the constraints. Build one automation. Run it on real data next to the team. Measure trust, not just task count. Then decide.
We have seen a two-week pilot save a team ten hours a week. We have seen a pilot reveal that the real problem was a missing field in the CRM, not the lack of automation. Both outcomes are useful. The second one costs far less than a custom integration project that solves the wrong problem.
If you have a process that lives in copy-paste, start there. Map it. We can help with the rest.
Comments
No comments yet. Be the first.