.png)
Nick Cottee
Founder, Zilla
.png)
Subscribe for email updates
We help streamline your funnel, boost conversions, and unlock more revenue.
.png)
Most content about ActiveCampaign falls into two buckets. AC’s own marketing tells you what it can do. Competitor comparisons tell you what it can’t, usually with an agenda. Neither is what you need if you’re running a business on the tool.
What you need is an honest list of the gaps, written by people who work inside AC every day, with a clear account of how each one gets solved in practice.
At Zilla we build automated marketing and sales ecosystems on ActiveCampaign for medium-sized businesses. We know the platform well enough to love it — and to know exactly where it’s going to make you work. Here are the eleven limitations we hit most often, and the workarounds we reach for.
The limitation. A rep can drag a deal from “Discovery” straight to “Closed Won” without filling in a single required field. AC doesn’t enforce data quality at stage transitions.
Why it bites. Your forecast is only as honest as the fields behind it. Without gating, the pipeline quietly becomes a lossy approximation of what’s actually happening.
The workaround. Replace native gating with automation-enforced gating. When a deal enters a gated stage, an automation checks for required fields and — if something’s missing — applies a “data incomplete” tag, pings the rep in Slack, and optionally rolls the deal back a stage. AC won’t stop users from doing the wrong thing, but it’s perfectly happy to react to it instantly, and that’s usually enough.
The limitation. A contact belongs to one account. A deal has one primary contact. If the same person sits across three client accounts, or a deal involves a buying committee of five, AC has no native way to represent that cleanly.
Why it bites. Real B2B sales are rarely one-to-one. You either lose visibility or pollute the CRM with duplicate contacts.
The workaround. Lookup fields cover simple cases. For complex B2B structures, model the relationships in an external table — Airtable is a common choice — and sync just enough back into AC for the sales team to see who else is involved. AC stays focused on what it does well; relational data lives where it belongs.
The limitation. You can require a field on a form. You can’t require it on the record itself. A rep can save a contact or deal with any field left blank.
Why it bites. Data hygiene issues compound silently. Your renewal reminder just stops firing for every deal where someone forgot to set the anniversary date.
The workaround. Automation-enforced validation. On every create or update, a lightweight automation checks critical fields and flags anything missing. The owner gets notified, the record gets tagged, and for the highest-stakes fields, downstream automations pause until it’s fixed.
The limitation. AC’s custom reports tool is newer than the rest of the platform and still has rough edges. The most common one: custom date fields are read as text strings, not real dates.
Why it bites. If your team can’t answer a reporting question in thirty seconds, they stop trusting the system. Friction at the reporting layer kills adoption.
The workaround. Create a parallel “report-friendly” version of each date field, populated automatically from the source. Reports read the clean field; automations keep using the source. For deeper analysis, pipe data into Looker Studio or Sheets so the reformat happens once at the sync layer.
The limitation. Account A can’t be linked to Account B. Deal 1 can’t be linked to Deal 2. There’s no native concept of a relationship between records of the same object.
Why it bites. Parent/child companies, referral chains, renewals tied to previous deals — none of it can be modeled natively. Teams end up tracking these in spreadsheets that drift out of sync.
The workaround. Keep the relationships in an external relational table with IDs mapping back to AC records. A reference field in AC lets users jump to the related-records view. Where the relationship needs to surface on the AC record itself, a custom field maintained by automation handles the summary.
The limitation. Moving from HubSpot, Pipedrive, or Salesforce into AC is mostly straightforward — except for deal notes. Native imports don’t carry them, and the API path isn’t obvious.
Why it bites. Notes are the history of every deal your team has worked. Lose them and reps lose trust in the new system immediately.
The workaround. A custom migration. Smaller moves can be handled in Zapier or Make: pull notes from the source, write them as timestamped notes on the correct deal, preserve the author where possible. For larger migrations, script directly against the AC API with error handling and a verification pass. Budget for this — it’s almost never included by default in migration scopes.
The limitation. AC’s automation builder works with triggers, actions, conditions, and field values. What it doesn’t give you is real variables — you can’t compute a value, do date math, transform a string, concatenate fields, or hold a temporary calculation between steps the way Zapier or Make can.
Why it bites. Any workflow that needs “take value A, combine it with value B, apply this rule, write the result back” becomes awkward inside AC. Discount calculations, formatted email content, next-renewal dates based on plan length, composite keys for deduplication — none of it happens natively.
The workaround. Run the transformation outside AC. Zapier or Make receives the trigger, does the computation, and writes the result back into AC as a field that downstream automations read. It adds a hop and a dependency, but it’s clean, easy to maintain, and keeps AC doing what it’s genuinely good at — orchestration and messaging — while the computation layer lives somewhere designed for it.
The limitation. AC has if/else logic and tag-based branching, but complex journeys sprawl fast. More than a couple of nested conditions becomes hard to read and painful to change without breaking something subtle.
Why it bites. Complex lifecycle journeys are exactly where you need automation most. If the tool fights back at complexity, you compromise the design.
The workaround. Split the logic. Instead of one giant automation, build smaller chained sub-automations, each responsible for a single decision. Tags act as the communication bus. More automations to manage; easier automations to read, test, and update. Modular systems survive team turnover. Monolithic ones don’t.
The limitation. AC won’t warn you about, merge, or prevent duplicate contacts or deals. A form submitted with a slightly different email, a Zap that fires twice, an integration with a soft-match bug — any of these creates silent duplicates.
Why it bites. Reports drift, automations re-run against the wrong record, marketing emails go out twice with mismatched personalisation — and the problem gets discovered late, at scale.
The workaround. Two layers. At the entry points, dedupe logic looks up existing records before creating new ones. At the maintenance layer, a scheduled automation scans for likely duplicates and flags them for review. We deliberately don’t auto-merge — the cost of a bad merge is higher than a manual review every week.
The limitation. You can’t say “only the finance team can see the commission field.” AC’s permissions model works at the record or object level, not the field level.
Why it bites. For sensitive data — commission rates, margins, health or legal context — this is a meaningful gap. “Train your team not to look” is not a security model.
The workaround. Shape visibility through structure. Sensitive data goes into dedicated pipelines, lists, or accounts with tightly scoped user assignments. For genuinely regulated data, a different tool holds the sensitive record — AC references it by ID, and the data lives in a system designed for that risk profile.
The limitation. Tracking a contact’s journey across pipelines — nurture into sales into onboarding into renewals — isn’t a first-class reporting concept in AC. As a deal transitions between pipelines, attribution to the original source gets muddied.
Why it bites. Marketing leaders want to know “where did this revenue actually start?” Without a clean answer, attribution becomes a gut-feel argument.
The workaround. Maintain consolidated “source” and “stage history” fields on every deal, populated automatically on every create, update, or transition. Reporting runs off those fields — inside AC where it can, or in Looker Studio / Sheets where it can’t. Clean cross-pipeline view, no fighting the native tool.
Read a list of eleven limitations and it sounds damning. It isn’t — and that’s the point most “honest reviews” miss.
Every CRM has a list like this. HubSpot’s is different but just as long, and you pay four times as much to discover it. Salesforce’s is longer still, and usually requires a dedicated admin. Pipedrive’s is shorter mostly because the tool does less.
The right question isn’t “which CRM has no limitations?” — none does — but “which CRM is the best engine for the business I’m actually running, and do I have someone who knows how to work around its specific gaps?”
For the businesses Zilla serves — medium-sized, growing, strong lead flow, small team carrying too much manual work — ActiveCampaign hits a rare sweet spot. Real automation depth without enterprise complexity. Integrated email without a separate ESP. Pricing that isn’t the biggest line item in your stack. The eleven limitations above are the price of that package, and with the right workarounds in place, the price is more than worth paying.
If you’d like a second set of expert eyes on your account, book a free 30-minute ActiveCampaign health check with Zilla. We’ll review your setup, flag the issues most likely to bite you in the next six months, and leave you with a prioritized list of fixes — whether you end up working with us or not.
Book your free ActiveCampaign health check →
No pitch, no obligation. Just a straight read on where your account stands and what to do next.
Zilla is a specialist ActiveCampaign partner. We design automated marketing and sales ecosystems for medium-sized businesses — the kind of systems that let small teams handle the work of a big one, without hiring more staff.
