Helpdesk migration

Migrate from Awesome Support to Salesforce Service Cloud

Field-level mapping, validation, and rollback between Awesome Support and Salesforce Service Cloud. We move data and schema; workflows are rebuilt natively in Salesforce Service Cloud.

Awesome Support logo

Awesome Support

Source

Salesforce Service Cloud

Destination

Salesforce Service Cloud logo

Compatibility

83%

10 of 12

objects map 1:1 between Awesome Support and Salesforce Service Cloud.

Complexity

CModerate

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from Awesome Support to Salesforce Service Cloud crosses from a WordPress plugin data model to a typed SaaS object hierarchy. Tickets live as custom post types in wp_posts with responses as wp_comments, while Salesforce uses the Case object with a structured conversation thread model. We read the WordPress database directly (wp_posts, wp_postmeta, wp_comments, wp_terms) when the REST API add-on is inactive, enumerate all active add-on namespaces during discovery, and map each data namespace to the equivalent Salesforce field or custom property. File attachments migrate as Salesforce ContentVersion records re-uploaded from the WordPress media library. We do not migrate WordPress pages, themes, or site configuration; the decision to decommission the WordPress instance is separate from the data migration. We do not migrate Awesome Support workflows, canned responses as templates, or add-on automation rules as code.

Field-level fidelity

Every standard and custom field arrives verified.

Schema-aware mapping

AI proposes the map; you confirm before any record moves.

Relationships preserved

Parent–child, lookups, and ownership stay linked.

Full activity history

Calls, emails, meetings — with original timestamps.

Attachments & notes

Documents, uploads, and inline notes move with the record.

Why teams make this switch

Two sides of the same decision

Leaving

Awesome Support logo

Awesome Support

What's pushing teams away

  • The plugin changed ownership via auction, and support quality degraded significantly — one reviewer reported five years of cases with effectively no vendor response when things broke.
  • Frequent WordPress core and plugin updates cause conflicts that corrupt media libraries and break other plugins, creating maintenance overhead and instability.
  • Add-on fragmentation forces teams to purchase multiple premium bundles to get features that competitors bundle together, making the true cost higher than the headline price.
  • Lack of a reliable, well-documented REST API in the base install makes automated exports and integrations dependent on a paid add-on.
  • Multi-site WordPress environments and hosting conflicts often make the plugin behave unpredictably across different server configurations.

Choosing

Salesforce Service Cloud logo

Salesforce Service Cloud

What's pulling them in

  • Deep Salesforce ecosystem integration with Sales Cloud, Marketing Cloud, and custom Apex apps creates a single pane of glass for enterprise customer data and cross-functional workflows.
  • Omnichannel case routing — email, chat, phone, social, and messaging — unified under one case object means agents do not lose context when customers switch channels mid-interaction.
  • AI for customer service (Einstein AI / Agentforce) offers automated case classification, suggested replies, and chatbot routing that reduces Tier-1 ticket volume without manual rule authoring.
  • Entitlement and milestone tracking enforces SLA compliance natively, automatically calculating breach windows and surfacing violations to supervisors in dashboards.
  • Salesforce's massive AppExchange ecosystem provides pre-built connectors, industry-specific managed packages, and third-party tools that extend Service Cloud beyond its out-of-box capabilities.

Object mapping

How Awesome Support objects map to Salesforce Service Cloud

Each row shows how a Awesome Support object lands in Salesforce Service Cloud, including any object-level transformations, lookup resolution, or schema-design dependencies.

Typical mapping — final map is confirmed during the sample migration step.

Awesome Support

Ticket

maps to

Salesforce Service Cloud

Case

1:1
Fully supported

Awesome Support tickets (post_type = 'ticket' in wp_posts) map to Salesforce Case records. The WordPress ticket ID becomes the Case CaseNumber or a custom field src_ticket_id__c for traceability. Ticket subject migrates to Case Subject, ticket status (wpas_status) maps to Case Status with custom status values created in Salesforce to match renamed labels from Awesome Support settings. Priority and product associations from postmeta keys wpas_priority and any WooCommerce/EDD product link migrate to Case Priority and a custom product reference field.

Awesome Support

Ticket Response (Public Reply)

maps to

Salesforce Service Cloud

EmailMessage + Case Conversation

1:1
Fully supported

Public replies stored as wp_comments with comment_type = 'ticket_reply' map to Salesforce EmailMessage records linked to the Case via ParentId. The WhoId on EmailMessage references the Contact (or Guest Contact) created from the ticket submitter. Body content migrates as HTML with inline images preserved via ContentDocument re-upload. We preserve the original reply timestamp as EmailMessage.MessageDate for conversation timeline ordering.

Awesome Support

Private Note

maps to

Salesforce Service Cloud

Note

1:1
Fully supported

Internal agent notes stored as wp_comments with comment_type = 'ticket_note' map to Salesforce Note records linked via ContentDocumentLink to the parent Case. The private flag is preserved in a custom field is_internal_note__c so the customer's admin can configure visibility logic in Salesforce. Private notes are not exposed to the end customer in either system.

Awesome Support

Agent (WordPress User)

maps to

Salesforce Service Cloud

User

1:1
Fully supported

WordPress users with the Awesome Support agent role map to Salesforce User records. We extract display_name, user_email, and the agent role designation from wp_usermeta. User provisioning is sequential: the customer's Salesforce admin creates matching active Users before the Case migration phase runs, because Case.OwnerId requires a valid Salesforce User lookup. Agents without a matching Salesforce User are held in a reconciliation queue.

Awesome Support

Customer (Registered User Submitter)

maps to

Salesforce Service Cloud

Contact

1:1
Fully supported

Ticket submitters who are registered WordPress users (wpas_user_id in postmeta) map to Salesforce Contact records. The WordPress user_email and display_name become Contact Email and Name. We use Contact Email as the dedupe key during import to prevent duplicate Contact creation if the same user submitted multiple tickets. The Contact is created before the associated Case import so that Case.ContactId lookup is satisfied.

Awesome Support

Guest Ticket Submitter

maps to

Salesforce Service Cloud

Contact

1:1
Fully supported

Guest ticket submitters lack a WordPress user account and appear only in ticket postmeta (wpas_user_email, wpas_user_name). We extract these values, create a Contact record with the IsGuestContact flag set, and link it to the Case. Email address is preserved as the dedupe key. If a guest later registers, the customer can merge or link the records manually in Salesforce.

Awesome Support

Custom Fields

maps to

Salesforce Service Cloud

Custom Fields on Case or Custom Object

1:1
Mapping required

Awesome Support custom fields use postmeta keys prefixed wpas_ or the active add-on namespace. We enumerate every distinct custom field key across all tickets during discovery, map each to a typed Salesforce Custom Field (Text, Number, Picklist, Date, Checkbox) on Case or a related Custom Object, and create the schema before migration begins. Add-on-gated fields (Gravity Forms, billing, WooCommerce product) are mapped to equivalent Salesforce fields with a note in the scope document identifying which add-on originally owned the data.

Awesome Support

Tag

maps to

Salesforce Service Cloud

Labels (Case) or Custom Multi-Select Picklist

lossy
Fully supported

Tags stored as WordPress post terms (taxonomy = 'ticket_tag') migrate to Salesforce Case Labels or to a custom multi-select picklist field on Case, depending on the customer's preference. The customer selects tag strategy during scoping. Multi-select picklist values are migrated as delimited strings in a single field; Labels create Salesforce TopicAssignment records linked to the Case.

Awesome Support

File Attachment

maps to

Salesforce Service Cloud

ContentVersion + ContentDocumentLink

1:1
Fully supported

Attachments stored as WordPress media items linked to the ticket post type are extracted as URLs from wp_postmeta (wpas_attachments) and wp_posts guid fields. We validate each URL for a 200 response, re-upload valid files as Salesforce ContentVersion records, and link them to the Case via ContentDocumentLink. Files returning 404 or redirect errors are flagged in the reconciliation report with the source ticket reference for manual recovery from the original email thread or backup.

Awesome Support

Satisfaction Survey Result

maps to

Salesforce Service Cloud

Custom Field on Case

1:1
Fully supported

Satisfaction survey data (wpas_satisfaction_rating, wpas_satisfaction_feedback) is only present when the Satisfaction Survey add-on is active. We check for the add-on during discovery, and if present, map the rating to a custom Number field cs_satisfaction_rating__c and feedback text to a custom Text Area field cs_satisfaction_feedback__c on Case. If the add-on is inactive, this object is omitted from the migration scope with a note in the scope document.

Awesome Support

Time Tracking Entry

maps to

Salesforce Service Cloud

Custom Object or Custom Field on Case

1:1
Fully supported

Time tracking entries stored by the Time Tracking add-on exist in a custom table or postmeta namespace (wpas_timetracking_). Each entry includes agent ID, duration in minutes, and optional billing notes. We map these to a custom Time_Entry__c object with fields for Case lookup, Agent lookup, Duration__c (Number), and Billing_Notes__c (Text), or to custom fields on Case if the customer prefers a simpler schema. The choice is confirmed during scoping.

Awesome Support

Custom Status Label

maps to

Salesforce Service Cloud

Case Status Picklist Values

lossy
Fully supported

Awesome Support allows renaming default status labels via settings (e.g., renaming 'Open' to 'In Progress'). We read the current status label configuration from wp_options during discovery, map each renamed label to a corresponding Salesforce Case Status picklist value, and configure the Case Status picklist in Salesforce to match the renamed labels exactly. Agents see the same label names in Salesforce that they saw in Awesome Support.

Gotchas + challenges

What specifically takes care here

Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.

Awesome Support logo

Awesome Support gotchas

High

No REST API in the free version blocks scripted migration

High

Ownership change via auction disrupted support continuity

Medium

Plugin updates corrupt WordPress media library

Medium

Add-on fragmentation spreads data across multiple schemas

Low

Guest ticket submitters lack a persistent contact record

Salesforce Service Cloud logo

Salesforce Service Cloud gotchas

High

Data Export 512MB file size cap breaks large org exports

High

API Daily Request Limits vary by license edition

High

No automatic data backup in base Salesforce

Medium

Picklist dependencies silently break records when unmapped

Medium

Workflow rules fire unexpectedly during data load

Pair-specific challenges

  • No REST API in the free tier means direct database extraction

    The REST API add-on is a paid extra. Without it, there is no programmatic export endpoint for ticket data, and migrations require read-only SQL queries against wp_posts, wp_postmeta, wp_comments, wp_terms, and wp_term_taxonomy. We run these queries server-side with a read-only database user that has no write permissions, extract all ticket post types and their associated meta and terms, then parse the result set server-side before transform. We confirm the REST API add-on status during scoping and adjust the extraction method accordingly. Migrations without the add-on require access to the WordPress database (host, port, credentials, database name) rather than an API key.

  • Add-on data scattered across five+ distinct meta namespaces

    Time tracking, satisfaction surveys, Gravity Forms data, billing records, and product associations each use a different meta key prefix or custom table when their add-on is active. We enumerate all active Awesome Support add-ons from the WordPress plugin list during discovery, then query every relevant meta key prefix to ensure no add-on-gated data is missed. If a bundle license has lapsed and the add-on is inactive, we note which data is absent and omit it from the migration scope rather than attempting to reconstruct it from incomplete postmeta.

  • Plugin updates corrupt the WordPress media library

    At least one reviewer documented a scenario where an Awesome Support update damaged the WordPress media library, breaking attachment URLs stored in ticket postmeta. We validate every attachment URL during the extraction phase, flag any that return 404 or redirect errors in a reconciliation report, and re-upload from a backup source or re-attach from the original ticket email thread if available. Large media libraries with thousands of attachments may require a staged re-upload process with a separate media migration task.

  • Guest ticket submitters lack WordPress user accounts

    Unauthenticated guests who submit tickets by email and name do not have a wp_users entry, so there is no persistent contact record in WordPress. We extract the guest submitter details from ticket postmeta (wpas_user_email, wpas_user_name), create a Contact record in Salesforce with the IsGuestContact flag, and link it to the Case. If multiple tickets were submitted by the same guest email, we deduplicate to a single Contact during import to avoid creating duplicate Contact records.

  • Salesforce validation rules and field-level security block import

    Salesforce orgs commonly enforce validation rules (required formats, conditional required fields, picklist whitelists) and field-level security that block records during data load. We coordinate with the customer's Salesforce admin to grant the migration user profile the necessary field-level permissions before load, and we either temporarily disable validation rules or extend them with a migration-context check that bypasses the rule for records inserted by the migration user. Skipping this step results in partial record rejection on first import attempt, typically 5-20 percent of records depending on how many custom fields and picklists are in use.

Migration approach

Six steps for a successful Awesome Support to Salesforce Service Cloud data migration

  1. Discovery and add-on enumeration

    We audit the source WordPress site across the active plugin list, Awesome Support version, REST API add-on status, and ticket volume estimate. We enumerate every active add-on, query the corresponding meta key namespaces in the WordPress database, and produce a written discovery document listing all objects to migrate, their source locations (postmeta key, custom table, or term taxonomy), and any add-ons whose data will be skipped because the add-on is inactive or the license has lapsed. We also assess whether the WordPress database is accessible via read-only credentials or whether a wp-cli export is required.

  2. Schema design in Salesforce

    We design the destination schema in Salesforce Service Cloud. This includes creating all custom fields referenced in the discovery document (with typed Salesforce field types matched to the source data format), configuring Case Status picklist values to match renamed status labels from Awesome Support settings, creating any custom objects required for time tracking or add-on-gated data, and setting up Page Layouts. Schema is deployed into a Salesforce Sandbox first via change set or metadata API for validation before production migration begins.

  3. Sandbox migration and reconciliation

    We run a full migration into a Salesforce Sandbox using production-equivalent data volume. The customer's Service Cloud admin reconciles record counts (Cases in, Contacts in, ContentDocuments in), spot-checks 20-30 random Cases against the WordPress source, and validates attachment presence and status label accuracy. Any mapping corrections, missing picklist values, or schema adjustments happen in the Sandbox and are redeployed before production migration begins.

  4. User provisioning and agent reconciliation

    We extract every distinct WordPress user with the Awesome Support agent role and match by email against the Salesforce destination org's User table. Any agent without a matching Salesforce User goes to a reconciliation queue for the customer's admin to provision before record import resumes. Case.OwnerId requires a valid Salesforce User lookup, so this step must complete before the Case migration phase runs.

  5. Production migration in dependency order

    We run production migration in record-dependency order: Contacts (registered users first, then guest submitters), ContentVersion records for attachments (to establish ContentDocument IDs before linking), Cases (with ContactId, OwnerId, and all custom field values resolved), Case Conversations (EmailMessage and Note records linked to Cases in timestamp order), and finally any custom objects for add-on data. Each phase emits a row-count reconciliation report before the next phase begins. We use the Salesforce REST API for small-volume batches and Bulk API 2.0 for histories exceeding 50,000 records.

  6. Cutover, attachment validation, and inventory delivery

    We freeze new ticket creation in Awesome Support during cutover, run a final delta migration of any Cases modified during the migration window, validate every ContentDocument attachment URL in Salesforce, then hand off the system as live. We deliver the written automation inventory documenting every Awesome Support workflow, canned response, and add-on rule requiring rebuild in Salesforce Flow or the customer's admin rebuild scope. We do not rebuild automations as Salesforce Flow inside the migration scope; that is a separate engagement.

Platform deep dives

Context on both ends of the pair

Awesome Support logo

Awesome Support

Source

Strengths

  • Free core tier includes unlimited tickets, agents, and full ticket history with no per-seat cost.
  • Lifetime one-time purchase option eliminates recurring subscription billing for budget-conscious teams.
  • WooCommerce and EDD integration handles support tickets linked directly to orders and digital products.
  • 30+ add-ons allow granular feature selection so teams pay only for what they need.
  • REST API add-on (when active) provides a documented endpoint surface for automated exports.

Weaknesses

  • No built-in REST API in the free version means migrations without the API add-on require direct WordPress database reads.
  • Frequent plugin updates create compatibility risk with WordPress core and other installed plugins.
  • Add-on proliferation means the real cost is higher than the base price, with features split across multiple bundles.
  • Support quality and development continuity became unreliable after the product changed ownership.
  • WordPress hosting dependency means performance and reliability are constrained by the hosting environment, not the plugin vendor.
Salesforce Service Cloud logo

Salesforce Service Cloud

Destination

Strengths

  • Enterprise-grade security, compliance certifications, and audit logging available across all paid editions with Shield offering enhanced event monitoring.
  • Scalable multi-tenant cloud architecture supporting orgs from 5 users to 150,000+ seat enterprises without infrastructure management overhead.
  • Omnichannel contact center unifying email, live chat, phone, messaging, and social into a single Case timeline per customer interaction.
  • Rich workflow automation via Salesforce Flow, Process Builder, and Apex triggers enabling complex case escalation, routing, and field updates.
  • Native AI capabilities (Agentforce / Einstein) for case auto-routing, classification, suggested responses, and chatbot escalation without third-party add-ons.

Weaknesses

  • Per-seat pricing model with no contact limits creates unpredictable cost scaling for large organizations adding many agents over time.
  • No automatic data backup — organizations must purchase a third-party backup solution or build manual Data Loader exports to protect against data loss from human error, failed deployments, or integrations overwriting records.
  • Steep learning curve for non-technical users requiring dedicated admin resources and formal training investment before teams reach productive velocity.
  • Annual contract requirements and limited pro-ration on exit create significant switching cost friction, especially for organizations evaluating alternatives mid-cycle.
  • Add-on licensing (CPQ, Einstein Activity Capture, Shield, Data Cloud) can double effective per-seat cost without clear documentation of which features are included in base tiers.

Complexity grading

How hard is this migration?

Moderate Helpdesk migration. 1 of 7 objects need a manual workaround.

C

Overall complexity

Moderate migration

Derived from compatibility, mapping clarity, API constraints, and data volume across Awesome Support and Salesforce Service Cloud.

  • Object compatibility

    C

    1 of 7 objects need a manual workaround.

  • Field mapping clarity

    C

    Field mapping is derived from defaults — final spec confirmed during the sample migration.

  • Timeline complexity

    B

    7-object category — typical timelines run 2–7 days end-to-end.

  • API constraints

    B

    Awesome Support: Not publicly documented.

  • Data volume sensitivity

    B

    Awesome Support doesn't expose a bulk API — REST + parallelization used for high-volume runs.

Estimator

Estimate your Awesome Support to Salesforce Service Cloud migration cost

Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.

Step 1

What are you migrating?

Pick a category, then your source and destination platforms.

Category

FAQ

Frequently asked questions about Awesome Support to Salesforce Service Cloud data migrations

Answers to the questions buyers ask most during Awesome Support to Salesforce Service Cloud migration scoping. Not seeing yours? Book a call.

Can't find your answer?

Walk through your Awesome Support to Salesforce Service Cloud migration with a real engineer — 30 minutes, free, written quote within 24 hours.

Book a free 30 minute consultation

Most migrations land between three and five weeks for accounts under 15,000 tickets with the REST API add-on active and fewer than three active add-ons. Migrations without the REST API add-on, with five or more active add-ons, or with large media attachment libraries move to seven to twelve weeks because of direct database extraction complexity, add-on namespace enumeration, and ContentVersion re-upload time. Salesforce Sandbox setup and User provisioning are on the critical path and can extend timelines if the customer's admin has limited availability.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Awesome Support.
Land in Salesforce Service Cloud, intact.

Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.

Accuracy guarantee Rollback included Quote in 1 business day