How to Preserve Candidate Intelligence During a Keap Migration: Strategic Tagging

A Keap migration done wrong destroys in an afternoon what your recruiting team built over years. Names and email addresses survive every import. The qualitative intelligence — behavioral observations, engagement history, soft-skill assessments, pipeline nuance — does not survive unless a deliberate tag architecture is already waiting to receive it. This guide walks you through exactly how to build that architecture, validate it, and execute a migration that arrives in Keap with more usable candidate intelligence than you left the old system with. For the broader framework that governs this approach, start with our parent guide on dynamic tagging in Keap for HR and recruiting automation.

Before You Start

Complete these prerequisites before exporting a single record. Skipping any of them guarantees rework.

• Tools required: Access to your current CRM or ATS with export permissions, a Keap account with admin-level tag management access, and your automation platform account for import mapping logic.
• Time estimate: Taxonomy design — 2 to 4 hours. Tag creation in Keap — 2 to 4 hours. Import mapping — 1 to 3 hours. Validation — 2 to 4 hours. Full migrations of under 1,000 records can complete in two to three business days when the taxonomy is pre-built.
• Risks to know: The most common failure mode is treating Keap tags as an afterthought — applying them via bulk manual action after import instead of baking them into the import logic itself. This creates the tag inconsistency problem described in the What We’ve Seen block above. The second risk is migrating without archiving inactive records separately, which pollutes live pipeline views instantly.
• Team alignment required: Every recruiter who will create or search tags in Keap must agree to the naming convention before the migration begins. Post-migration enforcement of a convention no one approved is nearly impossible.

Step 1 — Audit Your Existing Candidate Data for Intelligence Categories

Before building any tag, you need a complete inventory of what candidate intelligence currently exists in your system — and what form it takes.

Export a representative sample of 50 to 100 candidate records from your current system. Include all available fields: standard fields (name, email, phone, location), structured fields (job title, skills, education), status fields (pipeline stage, last contact date), and any free-text or notes fields.

Review those records and group every type of intelligence into one of four categories:

• Pipeline position data: Where is this candidate in your hiring process right now? (Lead, Applicant, Phone Screen, Interviewed, Offered, Hired, Declined, Archived)
• Skills and competency data: What can this person do, at what level, in what domain?
• Behavioral and qualitative signals: Soft-skill notes, cultural fit observations, interview performance flags, salary expectation alignment.
• Engagement and timing data: Last contact date bucket, communication preference, re-engagement timing, referral source.

Every piece of intelligence in your audit should slot into one of these four buckets. If it doesn’t fit, you have a fifth category — add it now. Do not discard any category because it seems minor. Gartner research on CRM data quality consistently finds that the qualitative data HR teams consider “soft” is precisely what differentiates high-performing talent pipelines from static contact lists.

Document your category list. This is the structural input to Step 2.

Step 2 — Design Your Keap Tag Taxonomy

Your taxonomy is the naming system that makes every tag searchable, automation-compatible, and consistent across every team member who touches the system. Design it before creating a single tag in Keap.

Use a three-part naming convention: Category::Subcategory::Value

Examples:

• Pipeline::Status::Interviewed
• Pipeline::Status::Offered
• Skill::Language::Python
• Skill::Domain::DataEngineering
• Signal::Culture::StrongFit
• Signal::Interview::NeedsFollowUp
• Engagement::Source::Referral
• Engagement::Timing::ReEngage2025Q1
• Migrated::Archive::Inactive2023

For a deeper reference on naming structures and organizational hierarchy, see our guide to Keap tag naming and organization best practices.

Build your taxonomy in a shared spreadsheet with three columns: Tag Name (as it will appear in Keap), Category, and the Legacy Field or Note it maps to from your old system. This document becomes your migration mapping table in Step 4.

Rules to enforce during taxonomy design:

• No spaces — use camelCase or hyphens within value segments.
• No synonyms — choose one term and use it everywhere (not “Remote” and “WFH” and “WorkFromHome”).
• No orphaned tags — every tag in your taxonomy must have at least one planned automation trigger or search use case before it gets created.

Cross-reference your taxonomy against our list of 9 Keap tags HR teams need for recruiting automation to confirm you have the foundational tags covered before adding specialized ones.

Step 3 — Create All Tags in Keap Before the Import

Tags created during or after an import are the primary source of naming inconsistency. Create every tag from your taxonomy in Keap — manually, systematically, in one session — before any candidate data moves.

In Keap, navigate to CRM > Tags and create each tag using the exact name from your taxonomy spreadsheet. Assign each tag to the correct Keap tag category (which maps to your taxonomy’s Category field). Do not allow any team member to create tags outside this session until the migration is complete.

When finished, export Keap’s tag list and compare it against your taxonomy spreadsheet row by row. Every taxonomy tag must exist in Keap with the exact correct name. Fix any discrepancies before proceeding.

This step typically takes two to four hours for a taxonomy of 50 to 150 tags — the normal range for a recruiting team of 5 to 20 people.

Step 4 — Build the Field-to-Tag Mapping Table

Your migration mapping table translates every legacy field value into the corresponding Keap tag. This is the logic your automation platform will execute during import. Do not skip this step and plan to “tag things later” — manual bulk-tagging after import is where intelligence consistently goes missing.

Structure the mapping table with four columns:

1. Source Field: The field name in your export file (e.g., “Pipeline Stage”)
2. Source Value: The specific value in that field (e.g., “Phone Screen Complete”)
3. Keap Tag: The tag to apply (e.g., “Pipeline::Status::PhoneScreenComplete”)
4. Condition Notes: Any logic rule (e.g., “only apply if Last Activity Date is within 365 days”)

Build one row for every source value that has a corresponding tag. Values with no clean mapping need a decision: either create a new tag, roll the value into an existing tag, or flag the record for manual review. Document every decision. SHRM data on recruiting process consistency shows that undocumented migration decisions become the source of system-wide disputes six to twelve months later.

For notes fields and free-text observations, you cannot automate the mapping directly. Instead, create a tag called Migration::Review::ManualNotesPending and apply it to every record that has non-empty notes. This flags those contacts for a post-migration human review session where a recruiter reads the note and applies the appropriate signal or competency tags manually.

Review how Keap handles Keap custom fields alongside dynamic tags to confirm which legacy data points belong in fields versus tags before finalizing your mapping table.

Step 5 — Configure Your Automation Platform’s Import Logic

Your automation platform reads the export file and creates or updates Keap contacts — applying tags according to your mapping table as part of the contact creation event, not as a separate subsequent step.

Configure your scenario or workflow as follows:

1. Parse the source file row by row, one contact per iteration.
2. Map standard fields (first name, last name, email, phone, location) directly to Keap contact fields.
3. Map custom fields (salary expectation, graduation year, role preference) to corresponding Keap custom fields.
4. Apply tag logic using your mapping table: for each source field value, use a router or conditional branch to select the correct Keap tag and apply it to the contact via the Keap “Add Tag” module.
5. Apply the archive tag conditionally: if Last Activity Date is older than 365 days, apply Migrated::Archive::Inactive.
6. Apply the manual review tag conditionally: if the Notes field is non-empty, apply Migration::Review::ManualNotesPending.
7. Log errors to a separate data store or sheet for any record that fails contact creation so no data is silently dropped.

Test the scenario on ten records from your sample set before running the full import. Confirm that every tag applied in Keap matches what your mapping table prescribes for those records.

For context on how this import logic connects to broader automation architecture, see our guide to Keap ATS integration and dynamic tagging ROI.

Step 6 — Execute the Full Migration in Batches

Do not run the full import in one unmonitored batch. Structure the migration in batches of 100 to 250 records, with a brief review after each batch before continuing.

Batch execution serves two purposes: it limits the blast radius of any mapping error discovered mid-import, and it keeps Keap’s API rate limits from throttling your scenario and producing incomplete imports.

During each batch run, monitor your error log in real time. If error rates exceed 2% of records in a batch, pause the import, diagnose the root cause in the mapping logic, fix it, and then reprocess the failed records before continuing to the next batch.

Apply a Migrated::Batch::001 tag (incrementing per batch) to every contact processed in that run. This makes it possible to isolate and re-examine any specific batch if a mapping error is discovered later.

Step 7 — Validate Tag Integrity on a 10% Sample

After the full migration completes, run a structured validation before any team member begins using Keap for active recruiting work.

Pull a random 10% sample of migrated records — select records from early batches, middle batches, and final batches to get coverage across the full import. For each sampled record:

• Open the contact in Keap and review the full tag list.
• Open the corresponding record in the original source system.
• Confirm that every expected pipeline status tag is present.
• Confirm that skill and competency tags match what was recorded in the source system.
• Confirm that the archive tag is present on inactive records and absent on active ones.
• Confirm that the manual review tag is present on any record with notes.

Document any discrepancy. If error rates in the sample exceed 5%, reprocess the affected batch rather than attempting manual individual fixes. Harvard Business Review analysis of enterprise data migrations consistently identifies the validation step as the one most frequently skipped — and the one whose absence produces the most expensive downstream rework.

Parseur’s Manual Data Entry Report estimates that the cost of a data error compounds at roughly $28,500 per employee per year when that error propagates through dependent workflows. In recruiting, a tag mapping error that routes candidates to the wrong nurture sequence has exactly that compounding effect.

Step 8 — Complete Manual Intelligence Recovery for Flagged Records

Every record tagged Migration::Review::ManualNotesPending requires a human to read the original note and translate it into Keap tags. This is unavoidable — free-text intelligence cannot be automated.

Assign this work to the recruiter who owns each candidate relationship, not to a generic admin. The recruiter has context that determines whether a note means “strong signal” or “polite decline.” Schedule a structured review session — not an ongoing background task — so that it gets completed within two weeks of migration rather than drifting indefinitely.

When a record’s notes have been fully converted to tags, remove the Migration::Review::ManualNotesPending tag. When all records in this queue are cleared, that tag becomes dormant and can be archived — a clean signal that the migration intelligence recovery is complete.

How to Know It Worked

A successful migration passes all of the following checks:

• Zero orphaned contacts: Every migrated record carries at least one Pipeline::Status tag. A contact with no pipeline status tag is invisible to every recruiting automation.
• Tag count matches record count: The number of contacts in Keap with the Pipeline::Status::Applicant tag (or equivalent) matches the number of applicant records in your source system export.
• Manual review queue is cleared: No records remain tagged Migration::Review::ManualNotesPending after the review session.
• Downstream automations fire correctly: Trigger a test event for your most common automation (e.g., a nurture sequence trigger based on a Pipeline::Status tag) and confirm it reaches the correct candidate segment.
• Recruiter trust is intact: Ask each recruiter to search for three specific candidates and verify their tags look correct. If recruiters immediately find errors on their own accounts, the validation was insufficient.

Common Mistakes and Troubleshooting

Mistake: Building the taxonomy in Keap instead of in a document first

Creating tags directly in Keap without a master taxonomy document produces inconsistencies within hours. One team member creates “Skill::Python” and another creates “Skills::Python::Intermediate” before any naming rules are shared. Fix: freeze tag creation in Keap until the taxonomy document is finalized and circulated.

Mistake: Treating tag migration as a one-time IT task

Migrations built entirely by technical staff without recruiter input produce technically complete but operationally useless tag structures. The people who will search on “strong culture fit” need to define what that tag is called before the import runs, not after. Fix: require at least one working recruiter in every taxonomy design session.

Mistake: Migrating notes as Keap note records instead of tags

Keap note records are not searchable and cannot trigger automations. Migrating free-text notes as Keap Notes preserves the text but destroys the intelligence — because intelligence only has operational value when it is machine-readable. Fix: convert notes to tags using the manual review process in Step 8.

Troubleshooting: Automation platform returns API errors during import

Keap enforces API rate limits. If your scenario runs too many operations per second, contacts will fail to create. Fix: add a delay module between iterations (typically 1 to 2 seconds per record) and reduce batch size to 100 records. Review your error log to identify which records need reprocessing.

Troubleshooting: Duplicate contacts after migration

Duplicates occur when a contact exists in the source system under two email addresses and both records import successfully. Fix: run Keap’s duplicate merge tool immediately after the full import completes, before any automation touches the migrated records.

What Comes Next: Putting the Intelligence to Work

A completed migration is the starting line, not the finish line. The tag structure you built in this process is the operational spine for every automation your team will run in Keap — nurturing sequences, candidate scoring, re-engagement campaigns, and pipeline reporting all depend on the integrity of those tags.

Your next priorities after migration validation:

• Activate your dormant talent pool — start with our guide on reactivating your dormant talent pool with dynamic tags, which assumes exactly the archive tag structure you built in this migration.
• Build your first live automation — see building your first Keap dynamic tagging workflow for a step-by-step sequence that fires on the Pipeline::Status tags you just migrated.
• Revisit the parent pillar on dynamic tagging in Keap for HR and recruiting automation to see where tag-driven AI scoring fits once your foundation is stable.

The candidate intelligence your team accumulated belongs to you. A strategic migration ensures it arrives in Keap intact — and starts working for you from day one.