Loading tutorials…
Loading tutorials…
Tags, lists, and fields each have a 'right' use case — and an expensive 'wrong' one. Most accounts have data model debt that costs 12-18% engagement when tags and lists conflict. Here's the framework specialists use.
Who this is forOperators 3-12 months into ActiveCampaign who realize their data model 'just grew' and is now hard to query. Or new operators who want to set up the right structure on day one — choosing now is 10x cheaper than refactoring later.
What you'll need
Step 1
List = consent boundary. Tag = lightweight behavioral/interest marker. Field = structured attribute. Each has a different cost to add/remove and a different query behavior.
List: a compliance and consent record. Subscribing to a list means the contact agreed to receive marketing for that list. Lists have their own unsubscribe link in footers. Most accounts need 1-3 lists, not 20.
Tag: a lightweight label you attach to contacts. Free-form (e.g., `webinar-attended-jun26`, `interest-saas`, `score-tier-1`). Contacts can have hundreds of tags. Tags are the fastest, most flexible segmentation tool in ActiveCampaign.
Custom field: a structured attribute with a type (text, dropdown, date, number). One value at a time per contact. Use for stable, single-value data (Plan, Company, Phone, Last Engagement Date).
Critically: lists are the hardest to undo (they involve consent records). Tags are the easiest. Fields are in between — easy to add, painful to change type once they have data.
Step 2
One list per opt-in source. Newsletter, Customers, Webinar, B2B Whitepaper. Not by interest, not by lifecycle, not by industry.
Lists should answer: 'How did this contact opt in to marketing?' That's it.
Common 'right' list structure: `Newsletter` (general signup), `Customers` (post-purchase opt-in), `Webinar Attendees` (event opt-in), `B2B Lead Magnet` (gated content opt-in).
Common 'wrong' list structure: `SaaS Customers`, `E-com Customers`, `California Customers`, `High-Value Customers`, `Lapsed Customers`. Each of these should be a tag or a segment, not a list.
Why it matters: if 'High-Value Customers' is a list and someone churns, you have to manually unsubscribe them from one list and subscribe them to another. Tags update in 1 click via automation. Lists update in 5 clicks with potential consent issues.
Audit your current lists. Anything that isn't a consent boundary should be migrated to tags. Specialist accounts typically have 2-4 lists. Bloated accounts have 15-30.
Step 3
Tags are the workhorse. Behavior (clicked-pricing, opened-last-3), interest (interest-saas, interest-ecom), lifecycle (lifecycle-lead, lifecycle-customer, lifecycle-churned).
Use a consistent naming convention. Specialists typically use prefix-based tags: `lifecycle-customer`, `interest-saas`, `score-tier-1`, `event-attended-jun26`, `source-organic`.
Why prefixes: in the tag picker, prefixes group logically. Easier to find `lifecycle-*` tags than mixed alphabetical.
Multi-value is the killer feature. A contact can be `interest-saas` AND `interest-ecom` AND `interest-agency`. A dropdown field can only be one. Tag everything you want to query in combination.
Tags are easy to add and easy to remove via automation. If a contact's lifecycle changes from lead to customer, an automation can swap `lifecycle-lead` for `lifecycle-customer` in 1 step. Field updates require more setup.
Cap your active tags. Operators with 1,000+ tags accumulated over years should audit and merge — many duplicate or near-duplicate tags exist.
Step 4
Phone, Company, Plan, Last Engagement Date, Signup Source. Single-value, structured, with a type.
Fields excel at: data that has one correct value at a time. Phone number (one current number). Company (one current employer). Plan (one current plan). Last Engagement Date (one most-recent date).
Pick field type carefully: Text (free-form), Textarea (longer free-form), Dropdown (one of finite values), Date, Number, Currency. Changing type later when the field has data is messy.
Use dropdowns sparingly. They look clean but trap you — adding/removing options later is painful. Free-text fields with consistent input discipline are often more flexible.
Common 'right' fields: First Name, Last Name, Phone, Company, Job Title, Plan, Lifecycle Stage (dropdown), Last Engagement Date, Signup Source.
Common 'wrong' fields: Interest (use tags — multi-value), Engaged In Last 30 Days (use a segment — auto-updates), Has Purchased (use a tag — easier to query in combination).
Step 5
A real B2B customer's profile: 1 list (Customers), 8-12 tags (interest, behavior, lifecycle, score), 8-10 fields (name, company, plan, phone, role, last engagement, signup source).
Example contact in a clean data model: List = `Customers`. Tags = `interest-saas`, `interest-ecom`, `lifecycle-customer`, `plan-pro`, `score-tier-1`, `event-attended-webinar-jun26`, `clicked-pricing-last-30d`. Fields = First Name: `Saadi`, Company: `EverestX`, Job Title: `CEO`, Phone: `+1-555-0123`, Signup Source: `organic-search`, Last Engagement Date: `2026-05-20`, Plan: `Pro`.
Now imagine the segments this enables: 'SaaS customers on Pro plan engaged in last 14 days' = 3 tag filters + 1 date filter. 30 seconds to build.
Compare to a bloated model with 'SaaS Customers' as a list, 'Pro Plan' as a list, and engagement in a custom field. Same segment becomes a list intersection (often broken in AC) + a field calculation. Hours to debug.
Audit existing contacts: are they on the right list (consent), with the right tags (behavior/interest), and the right field values (stable attributes)? Misalignment here loses 12-18% engagement on every segment-targeted campaign.
Step 6
If your account is 6+ months in and the model 'just grew,' a structured migration plan is the only sane path — don't try to refactor in place.
Step 1: export everything. Contacts → Export. Save all 3 versions (lists, tags, fields).
Step 2: map. For each existing list, decide: is this a real consent boundary? If no, it becomes a tag.
Step 3: bulk-tag. For lists that become tags, use Contacts → bulk actions → 'Add a tag' on each list's members.
Step 4: unsubscribe from old lists, after the new tag is applied. This is the consent-sensitive step — if migrating from `SaaS Customers` list to `interest-saas` tag, contacts STAY subscribed to a master `Customers` list.
Step 5: prune custom fields. Anything that's actually a tag-like marker (Interest, Engaged-In-Last-30) → tag. Anything unused for 6+ months → delete.
Migration takes 4-8 hours for a typical 5K-contact account. Plan for it in one session; don't refactor in pieces.
Common mistakes
15+ lists where 2-3 belong
What goes wrong: Loses 12-18% engagement when tags + lists conflict — automations triggered on 'subscribe to list' fire for the wrong cohorts. Compliance audits become impossible because consent records are scattered. Unsubscribe footers expose only one list at a time, so contacts unsubscribe from one list and keep getting emails.
How to avoid: Audit lists. Migrate everything that isn't a consent boundary to tags. Most accounts collapse to 2-4 lists after audit.
Tags created ad hoc with no naming convention
What goes wrong: After 12 months, 300-800 tags accumulate. Operators can't find tags reliably; segments use the wrong tag. Drops segment accuracy 20-30% as similar tags (`saas-interest` vs `interest-saas` vs `saas`) split the audience.
How to avoid: Adopt prefix conventions: `lifecycle-*`, `interest-*`, `score-*`, `source-*`, `event-*`. Audit existing tags quarterly; merge duplicates.
Using custom fields for multi-value data
What goes wrong: A 'Industry' dropdown with one value per contact can't capture 'SaaS + E-com' for an agency client. Loses the ability to target compound interests — drops campaign relevance 15-25%.
How to avoid: Move multi-value data to tags. Use fields ONLY for single-value structured data (one phone, one plan, one company).
Never auditing or pruning the data model
What goes wrong: Tags accumulate. Fields accumulate. Lists accumulate. Account performance degrades — segments take 10-30 seconds to load. New team members can't onboard because the model is undocumented.
How to avoid: Quarterly audit: prune unused tags (no contacts in 90 days = delete), unused fields (no values in 6 months = delete), and verify list count stays at 2-5.
Storing engagement state in fields instead of tags or segments
What goes wrong: A 'Engaged in last 30 days' field requires a daily automation to update. The automation breaks, the field goes stale, segments based on it are wrong. Drops campaign targeting accuracy 30-50%.
How to avoid: Use tags applied by automations OR auto-updating segments (e.g., 'opened campaign in last 30 days' as a segment rule). Don't try to store derived state in fields.
Importing CSV columns as fields when they should be tags
What goes wrong: Import wizard tempts you to map every CSV column to a field. After import, you have 25 new fields and no tags. Segments are slow and brittle.
How to avoid: On every import, ask: 'Is this a stable single-value attribute, or a behavioral/interest marker?' Fields for stable, tags for behavior/interest. Most CSV columns are tag candidates.
Recap
Done — what's next
How to set up an ActiveCampaign account the right way
Read the next tutorial
Hand it off
Data model is one of the highest-leverage parts of ActiveCampaign to get right. A specialist audit + refactor takes 4-8 hours for a typical 5K-contact account — usually $300-700 at $14-16/hr. Most operators recover that within 60 days from cleaner segment-targeted campaigns alone.
See specialist rates
If it isn't a unique consent record from a specific opt-in source, it should be a tag. 'Newsletter' and 'Customers' are lists (real consent boundaries). 'SaaS Industry,' 'High-Value,' 'Webinar Attended' are all tags. The test: would unsubscribing from this make sense as a separate action? If yes, it's a list. If no, it's a tag.
Technically thousands, practically you'll never hit it. ActiveCampaign handles 100-200 tags per contact comfortably. The real limit is your ability to maintain naming conventions across that many. Adopt prefixes (`interest-*`, `lifecycle-*`) so the tag picker stays usable.
Yes, with effort. Export contacts with the field value. In a spreadsheet, generate the tag name (e.g., `industry-saas` for field value 'SaaS'). Re-import with the tag column mapped, applying tags. Then delete the field. Budget 2-3 hours for a single field-to-tag conversion on a 5K-contact account.
Tag, not list, not field. Lifecycle is a single-value-at-a-time concept that changes over time — exactly what tags excel at (one swap per automation). A 'Lifecycle Stage' field works too but is harder to query in combination with other markers. Convention: `lifecycle-lead`, `lifecycle-customer`, `lifecycle-churned`.
8-15 for most operators. Fewer than 8 means you're under-capturing structured attributes. More than 30 starts slowing segments and overwhelms the contact view. If you have 50+ fields, audit — most are probably tag candidates.
No on both. Tags don't affect sender reputation or pricing — pricing is contact count + tier. Adding 50 tags per contact has zero impact on cost or deliverability. Use tags freely; that's their advantage over fields and lists.
ActiveCampaign
ActiveCampaign rewards careful setup more than almost any other email platform — get the plan, auth, and import order wrong and you're cleaning up data for months. Here is the setup sequence that doesn't trap you in 60 days.
ActiveCampaign
The automation builder is ActiveCampaign's highest-leverage feature — and the place most operators get stuck. Triggers, conditions, and goals each have a 'right' way that doesn't show up in the in-app tutorial. Here's the build that scales.
ActiveCampaign
ActiveCampaign's CRM is genuinely good for SMB sales — but only if pipeline stages match how your team actually sells. A pipeline copied from a generic template loses 20-30% of deal velocity. Here's the build that fits your motion.
ActiveCampaign
One email, four audiences. Conditional content is how mature operators send one campaign and let each subscriber see content matched to their segment. Done wrong, it leaks unmasked variables and breaks deliverability. Here's the build that scales.
ActiveCampaign
DIY ActiveCampaign works — until the automations stack, the data model frays, and you spend more time debugging flows than running the business. This is the honest framework: when the cost of self-managing exceeds the cost of hiring.