---
title: "Salesforce Service Cloud vs Thena (2026): Architecture, TCO & Migration"
slug: salesforce-service-cloud-vs-thena-2026-architecture-tco-migration
date: 2026-08-25
author: Abdul
categories: [Salesforce Service Cloud, Migration Guide, Help Desk]
excerpt: "Compare Salesforce Service Cloud and Thena: architecture, data models, pricing, API limits, AI capabilities, and step-by-step migration paths in both directions."
tldr: Salesforce Service Cloud is a relational CRM for enterprise support ops ($165–$500/user/mo). Thena is a Slack-native AI-first B2B support tool ($29–$119/user/mo). No native migration path exists.
canonical: https://clonepartner.com/blog/salesforce-service-cloud-vs-thena-2026-architecture-tco-migration/
---

# Salesforce Service Cloud vs Thena (2026): Architecture, TCO & Migration


# Salesforce Service Cloud vs Thena (2026): Architecture, TCO & Migration

> [!NOTE]
> **TL;DR:** Salesforce Service Cloud is a relational CRM platform where Cases live inside Accounts, Contacts, Assets, and Entitlements — designed for enterprise orgs that need support data woven into sales and revenue operations. Thena is a Slack-native, AI-first B2B support platform that detects requests inside messaging channels and converts them into structured tickets. They solve different architectural problems at different price points ($165–$500/user/month vs. $29–$119/user/month). No native migration path exists between them — every move requires custom API scripting and careful data model translation.
>
> *Pricing verified against Salesforce list pricing (July 2026) and Thena pricing page (May 2026). API behavior verified against Salesforce REST API v66.0 (Spring '26) and Thena API docs (docs.thena.ai). Confirm live figures before signing.*
>
> **Changelog:** Updated July 2026 — Corrected Thena Standard-tier API rate limit from 100 RPM to 60 RPM; updated Agentforce pricing from $2.50/conversation to $2/conversation; added Salesforce GDPR DPA/SCC details to compliance section.

Salesforce Service Cloud and Thena appear in the same evaluation cycle when a team's support model is shifting — either from enterprise CRM-driven operations toward channel-native B2B support, or from a Slack-first startup motion toward a structured, cross-functional CRM. (This is similar to how [LiveChat and Thena](https://clonepartner.com/blog/blog/livechat-vs-thena-2026-architecture-tco-migration/) overlap when teams shift from B2C website chat to B2B Slack support.)

These platforms share almost zero architectural DNA. Choosing between them — or migrating from one to the other — is an infrastructure decision, not a feature comparison. The right choice dictates how your support organization will scale over the next five years.

This guide covers the real differences: data models, pricing math, API constraints, AI capabilities, compliance posture, and the exact migration paths in both directions. Where Thena has advantages, that's documented. Where Thena has structural ceilings, those are documented too.

## Who Each Platform Is Built For

**Salesforce Service Cloud** is the service module of Salesforce's multi-tenant CRM platform. Cases are first-class objects embedded within a deeply relational schema that connects to Accounts, Contacts, Opportunities, Assets, Entitlements, and every AppExchange integration in your org. The ICP is a B2B or B2B2C organization with 20–500+ agents, high CRM maturity, and active use of Sales Cloud or Marketing Cloud in the same org.

**Thena** is an AI-native B2B customer support platform built around Slack and Microsoft Teams as primary support channels. Instead of forcing customers into a portal to fill out a structured form, Thena lives where B2B conversations already happen. It unifies conversations from Slack, MS Teams, Discord, email, and web chat into structured tickets with account-centric context. The ICP is a B2B SaaS team with 5–50 support staff where high-value customers communicate via Slack Connect and expect fast, conversational support.

> [!TIP]
> **The deciding factor is almost always your primary support channel and your CRM dependency.** If your support data must link directly to sales pipeline, contract entitlements, and asset hierarchies, Salesforce's relational model matters from day one. If your customers already live in Slack Connect and your team doesn't need a shared CRM database with sales, Thena delivers faster time-to-value at a fraction of the cost. Use **relationship density** — not raw ticket volume — as the primary signal.

## Architecture and Data Model

The fundamental difference between these platforms lies in how they conceptualize a support interaction.

### Salesforce Service Cloud: The Relational Database

Salesforce is not a standalone helpdesk — it is a CRM platform where support is one application running on top of a massive relational database. A `Case` is never just a ticket. It is a highly structured object linked via foreign keys to an `Account`, a `Contact`, an `Asset`, an `Entitlement`, and potentially a `Service Contract`. This architecture is mandatory for hardware manufacturers, complex B2B enterprises, and financial services firms that require granular SLA tracking based on specific purchased assets.

Key relationships:

- **Case → Account → Contact**: Every case links to the customer's account and contact record, which also carries sales pipeline, billing, and contract data.
- **Case → Asset → Entitlement**: Support cases can reference specific products (Assets) and contractual service terms (Entitlements and Service Contracts).
- **Case → Opportunity**: Cross-object reporting lets RevOps teams correlate support load with revenue.
- **Custom Objects**: Unlimited custom object creation to model any business entity.

To query a closed case and understand its full context, you must traverse multiple objects:

```sql
/* SOQL query demonstrating relational depth */
SELECT Id, CaseNumber, Subject, Status, 
       Account.Name, Contact.Email, 
       Entitlement.Name, Asset.SerialNumber
FROM Case
WHERE Status = 'Closed' 
AND CreatedDate = LAST_N_DAYS:30
```

If you need the actual conversation, you must separately query `EmailMessage`, `LiveChatTranscript`, or `FeedItem` objects, all of which link back to the parent `Case`. On the operations side, Omni-Channel routes cases, chats, messaging sessions, and voice work — including skills-based routing and unified routing flows. ([developer.salesforce.com](https://developer.salesforce.com/docs/data/data-cloud-ref/guide/c360dm-case.html))

**Key architectural traits:**

- **Multi-tenant architecture** with strict governor limits on API calls, database queries (SOQL), and script execution time
- **Object-oriented** — relationships (Lookup, Master-Detail) define data visibility and reporting
- **Extensible** via custom Apex code, Lightning Web Components (LWC), and 3,000+ AppExchange integrations

**Known structural constraints relevant to migration:**
- `CaseComment` body is capped at **32,000 characters**. Slack threads that exceed this limit must be split, truncated, or stored as attached files — a common trap for thread migration.
- `EmailMessage` storage counts against your org's data storage allocation. High-volume email-to-case orgs can exhaust storage during migration if this is not planned for.
- Bulk API v2 may not be enabled by default on older Salesforce orgs provisioned before Spring '19. Verify org feature flags before assuming v2 availability.

### Thena: The Conversational Layer

Thena approaches support from the opposite direction. Its architecture is conversational and event-driven — it listens to webhooks from messaging platforms, applies AI to detect intent, and structures unstructured chat into trackable requests.

**"AI-native"** in Thena's context means AI intent detection runs at ingest, before any human agent sees the message. There is no manual triage step. **"Event-driven"** means the system reacts to Slack API event subscriptions rather than polling — latency is low, but webhook retry behavior matters: if Thena's webhook endpoint does not receive a 200 response within 3 seconds, Slack retries up to 3 times before dropping the event. During cutover windows, this retry behavior must be accounted for in routing logic.

The primary data objects:

- **Request (Ticket)**: The core object, created automatically when Thena's AI detects a support request in a Slack channel, Teams conversation, or other connected channel.
- **Account**: All requests are organized under accounts — providing a single view of every customer's issues, conversations, and health signals.
- **Channel**: The originating source (Slack channel, email thread, web chat session, Discord).
- **Tags, SLAs, Custom Fields**: Metadata for routing, prioritization, and reporting.

The API returns a nested JSON structure that prioritizes the flow of messages and channel context:

```json
{
  "request_id": "req_987xyz",
  "channel": {
    "id": "C01ABCDEF",
    "name": "ext-acme-corp"
  },
  "customer": {
    "id": "cus_123abc",
    "name": "Acme Corp"
  },
  "status": "resolved",
  "messages": [
    {
      "user_id": "U01XYZ",
      "text": "The API is returning a 500 error on the /v2/users endpoint.",
      "timestamp": "1697040000"
    }
  ]
}
```

In Slack, teams can define customer channels, internal helpdesk channels, and triage channels. Tickets can be created automatically via AI detection, via emoji reaction, via `@Thena`, or via slash commands. Related messages can be grouped into a single ticket within a configurable window that defaults to two minutes. ([docs.thena.ai](https://docs.thena.ai/guides/onboarding/introduction))

**Key architectural traits:**

- **Event-driven** — heavily reliant on Slack/Teams API event subscriptions, with Slack's 3-second response / 3-retry failure model
- **AI-native** — parses unstructured text, summarizes long threads, and auto-categorizes intents without manual agent triage
- **Flat data model** — optimized for speed and conversational context rather than deep, multi-level asset tracking

**Thena's flat data model is a ceiling, not just a simplification.** If your support workflow eventually requires entitlement-based SLA enforcement, asset-level case tracking, or cross-object reporting with sales pipeline, Thena's schema will not accommodate those requirements without a platform change. Teams that outgrow Thena do so specifically at this boundary.

### The Architectural Split in Practice

If an agent needs entitlement status, asset context, escalation logic, and CRM reporting on the same screen, Salesforce's model matters. If the support team lives in shared Slack channels with customers and needs low-friction ticketing without asking customers to leave Slack, Thena's model matters.

Salesforce is not anti-Slack, and Thena is not anti-CRM. Salesforce offers Service Cloud for Slack and swarming directly from the Service Console. Thena offers a Salesforce app that synchronizes accounts and contacts, supports manual sync, and allows 4, 8, 12, or 24-hour sync intervals — though it deliberately does not auto-delete records in Thena when they are deleted in Salesforce. ([docs.thena.ai](https://docs.thena.ai/platform/apps/salesforce)) The difference is where the system of record sits. In Salesforce, Slack is an extension of the CRM workflow. In Thena, CRM sync is an extension of the channel workflow.

### Data Model Mapping

| Salesforce Service Cloud | Thena | Migration Notes |
|---|---|---|
| Case | Request | Core ticket object. Field mapping required for status, priority, custom fields. |
| Account | Account | Closest 1:1 mapping. Salesforce Accounts carry far more relational data. |
| Contact | User / Requester | Thena tracks requesters but without Salesforce's Contact depth. |
| Asset | — | No equivalent. Asset context must be stored in custom fields or dropped. |
| Entitlement | — | No equivalent. SLA configuration exists but is structurally different. |
| CaseComment / FeedItem | Comment / Conversation thread | Thread structure differs. CaseComment body cap is 32KB. Slack-native threads ≠ Salesforce Chatter. |
| Knowledge Article | Help Center article | Content migration requires reformatting. Complex category hierarchies require Salesforce Metadata API. |
| Attachment (ContentDocument) | Attachment | File migration via API on both sides. Requires Query All Files permission in Salesforce. |

## Pricing and TCO

License cost is only a fraction of the total expense. The real financial divergence between these platforms is human capital and add-on licensing.

### Salesforce Service Cloud Pricing (2026)

Salesforce Service Cloud pricing runs across five editions, all per-user, per-month, billed annually:

| Edition | List Price | Notes |
|---|---|---|
| Starter Suite | $25/user/month | Basic case management only. Not viable for a real support operation. |
| Pro Suite | $100/user/month | Adds automation and customization. |
| Enterprise | $165/user/month | Standard tier for mid-market B2B support teams. |
| Unlimited | $330/user/month | Full feature set including Premier Success. |
| Einstein 1 Service | $500/user/month | Bundles Agentforce, Data Cloud, and Service Intelligence. |

> [!WARNING]
> **The headline price is never the real number.** A typical Service Cloud Enterprise deployment with Digital Engagement ($75/user/month) plus Voice plus Field Service lands at $400–$600/user/month at list before discount. Agentforce starts at $2/conversation on top of your Service Cloud license. Budget all three layers — license, add-ons, implementation — before signing.

Hidden costs that define the TCO:

- **Administration**: You cannot run Salesforce without a dedicated, certified Salesforce Administrator (average US salary: $95,000–$120,000 per LinkedIn Salary and Glassdoor aggregate data, 2025–2026). Complex orgs also need a Salesforce Developer ($130,000–$160,000).
- **Implementation**: Initial deployment usually requires a Systems Integrator partner, costing $30,000–$250,000+ depending on complexity, with timelines of 3–6+ months.
- **Add-ons**: Features like Knowledge, Digital Engagement (chat/SMS), and Einstein AI often require separate licensing on Enterprise tier and below.

### Thena Pricing (2026)

Thena offers three tiers, all billed annually:

| Plan | List Price | Key Constraints |
|---|---|---|
| Starter | $29/user/month | Max 5 seats, 1,000 tickets/month, Slack + email only |
| Standard | $79/user/month | AI web chat, AI Agent Studio, MCP integration, API access, workflows |
| Enterprise | $119/user/month | MS Teams, custom AI deployments, enterprise APIs, enhanced security |

The Starter plan's 1,000-ticket monthly cap pushes growing teams to Standard quickly. API access is gated to Standard and above. Microsoft Teams integration requires Enterprise.

Hidden costs are narrower:

- **Administration**: Thena requires almost zero dedicated administrative overhead. Support operations managers configure routing rules and AI triggers directly within the web app or Slack.
- **Implementation**: Deployment is measured in hours or days, not months. Authorize the Slack workspace, map channels, and begin routing.
- **Slack licensing**: To use Slack Connect effectively with external customers, both you and your clients need paid Slack plans (~$8–$15/user/month per Slack's Pro/Business+ pricing).

### 50-Agent TCO Scenario

For a 50-agent team over 12 months (list prices, before negotiation):

| Cost Component | Salesforce Enterprise | Thena Standard |
|---|---|---|
| Base licenses | $99,000/yr | $47,400/yr |
| Digital Engagement add-on | $45,000/yr | Included |
| Implementation / admin (Year 1) | $50,000–$150,000 | $5,000–$15,000 |
| AI layer | $2/conversation (variable) | Included in plan |
| **Estimated Year-1 TCO** | **$200,000–$300,000+** | **$55,000–$65,000** |

**When the Salesforce cost is justified:** if your organization already runs Sales Cloud and Marketing Cloud in the same org and needs cross-object reporting, the relational database's value compounds across teams. If you are buying Salesforce *only* for support, the TCO gap is hard to justify against a purpose-built tool. Conversely, if you need Thena to eventually handle entitlement-based SLAs or asset-level tracking, you will hit its data model ceiling before you exhaust Salesforce's.

For a broader comparison of Salesforce Service Cloud cost structures, see our [Salesforce Service Cloud Alternatives guide](https://clonepartner.com/blog/blog/salesforce-service-cloud-alternatives-2026-tco-migration/) or our [architectural comparison with Zendesk](https://clonepartner.com/blog/blog/zendesk-vs-salesforce-service-cloud-the-2026-architecture-guide/).

## API Architecture and Rate Limits

### Salesforce APIs

Salesforce provides a broad API catalog: REST, SOAP, Bulk, Composite, Streaming, and Connect APIs, all drawing from the same daily request pool.

- **Daily limit**: Enterprise Edition starts at 100,000 requests/24 hours + 1,000 per user license (rolling window, not calendar day)
- **Bulk API**: 15,000 batches per 24-hour period
- **Concurrency**: Max 25 long-running requests (>20 seconds) in production
- **Composite API**: Single API call wrapping up to 25 subrequests (serial execution, cross-reference support)
- **REST pagination**: Query responses paginate at 2,000 rows; Bulk API 2.0 is better for large extracts
- **Bulk API v2 availability**: Not enabled by default on orgs provisioned before Spring '19 — verify in Setup → Feature Settings before building migration scripts against it

For migrations into Salesforce, Bulk API 2.0 is the standard approach. A 50-user Enterprise org gets roughly a 150,000 daily REST call budget. Plan extraction and loading windows accordingly. ([developer.salesforce.com](https://developer.salesforce.com/blogs/2024/11/api-limits-and-monitoring-your-api-usage))

Attempting to push high-volume transactional data — like individual Slack messages — into Salesforce as individual records will quickly exhaust your API limits and storage capacity. Best practice: summarize the thread in Thena and push a single, structured `Case` record to Salesforce containing the resolution.

### Thena API

Thena's API is a REST API accessible at `platform.thena.ai/v1/`. Authentication uses an `x-api-key` header tied to individual users.

- **Standard tier rate limit**: 60 requests per minute per user, org, and IP
- **Enterprise tier**: Custom limits negotiated per contract
- **Authentication**: API key generated from Dashboard → Organization Settings → Security and Access
- **Export**: UI-based export to XLSX or JSON; API-based extraction via the Get All Requests endpoint

> [!WARNING]
> **Thena's Standard-tier rate limit of 60 requests/minute is tight for bulk extraction. Here is the math:** 50,000 requests ÷ 60 RPM = 833 minutes of sustained API time, not accounting for pagination overhead, retry delays on 429 responses, or network latency. Realistically, budget 14–18 hours of extraction time for a 50,000-request dataset at Standard tier. When the API returns a 429, implement exponential backoff starting at 1 second — aggressive retry loops will extend the window further by triggering sustained rate-limiting. Negotiate Enterprise-tier custom limits before migration planning if your dataset exceeds 10,000 requests.

> [!CAUTION]
> **Do not attempt bidirectional, real-time sync between Thena and Salesforce for individual messages.** The latency and API overhead will cause race conditions. Sync the ticket state (Open/Closed) and the final summary, not the raw chat log.

For detailed extraction guidance, see our guides on [exporting from Thena](https://clonepartner.com/blog/blog/how-to-export-data-from-thena-methods-api-limits-formats/) and [exporting from Salesforce Service Cloud](https://clonepartner.com/blog/blog/how-to-export-data-from-salesforce-service-cloud-methods-limits/).

## AI and Automation

### Salesforce: Agentforce

Salesforce's AI layer is now branded **Agentforce** — autonomous AI agents that can resolve cases, route tickets, and execute multi-step workflows.

- Starts at **$2/conversation** on top of Service Cloud licensing
- Requires Data Cloud for full context (unified customer profiles from external sources)
- Pre-built agent templates for service resolution, but customization requires Salesforce admin/developer expertise
- Implementation timeline: **5–11 months** for production deployment in most enterprises
- Learns from data already in Salesforce — Cases, Contacts, Accounts, and Knowledge articles
- **Limitation**: Agentforce Service Agent handles inbound conversations only — it cannot proactively reach out to customers
- **Practical consideration**: Agentforce's effectiveness is proportional to the quality of your existing Knowledge article library and historical Case data. Orgs migrating *to* Salesforce without mature Knowledge content will see limited AI value in the first 6–12 months.

### Thena: AI-Native from Day One

Thena embeds AI at the platform level rather than as an add-on:

- **AI Request Detection**: Automatically identifies support requests inside Slack conversations — no manual ticket creation required
- **AI Agent Studio**: Build custom AI agents (Standard plan and above)
- **MCP (Model Context Protocol) integration**: Connect Thena to external AI models and tools
- **AI Copilot**: Suggests responses, summarizes threads, surfaces knowledge base articles
- AI capabilities included in every plan tier — no per-conversation billing

The fundamental difference: Salesforce's AI is powerful but layered on top of a complex CRM at additional cost with months of implementation. Thena's AI is baked in from the start, purpose-built for messaging-channel workflows, and included in the subscription. The tradeoff: Thena's AI operates on a flat conversational data model. It cannot cross-reference entitlement history, asset records, or sales pipeline unless those are manually synced in via Salesforce integration.

## Compliance and Security

### Salesforce Service Cloud

Salesforce maintains one of the broadest compliance portfolios in SaaS:

- SOC 2 Type II, SOC 1 Type II
- ISO 27001, ISO 27017, ISO 27018
- HIPAA (with Business Associate Agreement)
- FedRAMP (government cloud)
- PCI DSS
- **GDPR**: Salesforce publishes a Data Processing Agreement (DPA) and Standard Contractual Clauses (SCCs) for EU data transfers, covering both controller and processor obligations. Available at salesforce.com/content/dam/web/en_us/www/documents/legal/Agreements/data-processing-addendum.pdf.
- Data residency: Hyperforce enables deployment in specific regions (US, EU, APAC, and others)
- Encryption: Shield Platform Encryption for data at rest, TLS for data in transit

### Thena

Thena's compliance posture is narrower, consistent with its stage:

- SOC 2 Type II
- **GDPR**: Thena supports EU data subject rights (access, deletion, portability) and processes data as a data processor on behalf of customers. A DPA is available on request. EU data residency configuration details are not publicly documented at the same granularity as Salesforce — request explicit written confirmation from Thena's legal team before assuming EU-only data handling.
- No HIPAA BAA publicly listed
- No FedRAMP

> [!NOTE]
> **If your organization operates in healthcare, government, or a highly regulated industry**, Salesforce's compliance portfolio will likely be a hard requirement. Thena's SOC 2 coverage and GDPR DPA are sufficient for most B2B SaaS environments but will not clear procurement in healthcare or government verticals. For GDPR specifically, both platforms offer DPAs — but Salesforce's is more granularly documented and has been validated in EU procurement processes at scale.

## Migration: Salesforce Service Cloud → Thena

### When This Migration Makes Sense

- Your team has moved to Slack Connect as the primary support channel and Salesforce Cases have become a secondary logging system
- You're paying for Service Cloud licenses but not using Sales Cloud, Marketing Cloud, or the relational data model
- Support agents spend more time in Slack than in the Salesforce console
- Your TCO is inflated by add-ons you don't fully use

### Step 1: Schema Mapping and Identity Resolution

The most critical step is mapping identities. In Salesforce, a user is a `Contact`. In Thena, a user is defined by their Slack ID or email. Build a mapping table that links Salesforce `Contact.Id` to Thena's user identities. If a Slack user does not exist in Salesforce, define fallback logic — creating a stub Contact or mapping to a generic Account.

Map Salesforce Case Status values to Thena's status taxonomy (Open, Pending, Resolved, Closed). Salesforce Assets and Entitlements have no Thena equivalent — store relevant context in Thena custom fields or accept that data won't carry over.

### Step 2: Extract from Salesforce

Use the Bulk API 2.0 for high-volume extraction. Target objects in dependency order:

```
1. Account → maps to Thena Account
2. Contact → maps to Thena User/Requester
3. Case → maps to Thena Request
4. CaseComment / EmailMessage → maps to Thena conversation thread
5. ContentDocument + ContentDocumentLink → maps to Thena attachments
6. Knowledge__kav (if applicable) → maps to Thena Help Center articles
```

**Before running extraction, verify:**
- Bulk API v2 is enabled in your org (Setup → Feature Settings)
- The extracting user has the **Query All Files** permission — without it, `ContentDocument` records associated with archived or private files will be silently omitted
- `EmailMessage` storage usage — large email-to-case orgs may have tens of GB of message data; full extraction will be slow

Extracting attachments requires querying the `ContentVersion` object and handling Base64-decoded files. Email attachments may appear on the `EmailMessage` record or in case-related Files depending on how Email-to-Case was configured in the org. ([help.salesforce.com](https://help.salesforce.com/s/articleView?id=000384447&language=en_US&type=1))

### Step 3: Transform the Payload

Flatten the relational structure. A Salesforce Case with 10 EmailMessages must be transformed into a single Thena Request JSON payload, with the emails converted into sequential messages within the thread array.

**Known transformation failure modes:**
- **CaseComment body > 32,000 characters**: Salesforce enforces a 32KB body limit, but long comments created via API or older integrations can exceed this in legacy orgs. Validate before extraction; truncate or split on transform.
- **Rich Text (HTML) in CaseComments**: Salesforce stores CaseComment bodies as plain text, but Description fields and some Knowledge articles store HTML. Strip or convert HTML before loading into Thena.
- **Custom picklist values**: Salesforce picklist values not present in Thena's tag vocabulary must be mapped to Thena tags or custom fields before load, not after.

Convert Salesforce Rich Text (HTML) in CaseComments to Thena's supported format. Remap custom picklist values (priority, category, type) to Thena tags and custom fields.

### Step 4: Handle Attachments

Do not leave attachments behind. Download all binaries from Salesforce to a secure staging location (e.g., AWS S3). During the import to Thena, upload the binaries via API, retrieve the new hosted URL or ID, and rewrite inline image tags in the message bodies to point to the new location.

Attachment handling breaks more migrations than any other step. In Salesforce, historical attachments can sit behind `ContentVersion`, `ContentDocument`, `ContentDocumentLink`, and `EmailMessage` depending on how the org was configured over time. Orgs that pre-date the Spring '16 Files migration may still have legacy `Attachment` object records alongside modern `ContentDocument` records. Audit both object types before assuming your extraction is complete. ([help.salesforce.com](https://help.salesforce.com/s/articleView?id=000381137&language=en_US&type=1))

### Step 5: Load into Thena

Use Thena's Platform API (`POST /v1/requests` and related endpoints). At Standard tier's 60 RPM limit:

**Load time math:** 10,000 requests ÷ 60 RPM = 167 minutes. 50,000 requests ÷ 60 RPM = 833 minutes (~14 hours), excluding retry overhead. If the API returns a 429, implement exponential backoff starting at 1 second. Do not use fixed-interval retry — sustained 429s indicate you are already at the rate ceiling.

As of mid-2026, Thena's public docs document ticket export and platform APIs, but no comparable self-serve ticket import guide exists — treat production imports as API-led. ([docs.thena.ai](https://docs.thena.ai/guides/ticketing/export-tickets))

### Step 6: Delta Sync and Cutover

1. Run the historical migration (everything older than 7 days).
2. Validate data integrity, attachment links, and user mapping in a staging environment.
3. On cutover day, freeze the source system.
4. Run a delta script to catch any tickets updated in the last 7 days.
5. Route new webhooks/emails to Thena. Account for Slack's 3-second webhook response window — if your routing script is slow, Slack will retry up to 3 times and then drop the event.
6. Keep Salesforce read-only for at least 2 weeks post-migration as a rollback.

## Migration: Thena → Salesforce Service Cloud

### When This Migration Makes Sense

- Your company has outgrown a Slack-first support model and needs support data integrated with sales pipeline, contracts, and product assets
- You're adopting Salesforce across the organization and want a single CRM platform
- Regulatory or compliance requirements demand Salesforce's broader certification portfolio
- You need entitlement-based SLA management tied to customer contracts

### Step 1: Extract from Thena

Two approaches:

1. **UI Export**: Dashboard → Requests → Export (XLSX or JSON). Suitable for smaller datasets. The export respects current filters and date ranges, includes core fields, customer data, SLA tracking, and custom fields, and uses UTF-8 with BOM. ([docs.thena.ai](https://docs.thena.ai/guides/ticketing/export-tickets))
2. **API Extraction**: `GET /v1/requests` with pagination. At 60 RPM on Standard tier, budget time for large exports. **Math:** 10,000 requests ÷ 60 RPM = 167 minutes; 50,000 requests ÷ 60 RPM = ~14 hours at sustained throughput. Negotiate Enterprise-tier rate limits if you have 10,000+ requests and cannot wait.

Ensure you capture the full message array within each request — this contains the actual support context. The UI export does not always include the complete conversation thread; API extraction is required for full message fidelity.

### Step 2: Transform and Enrich

Enrich Thena's flat records for Salesforce's relational model. As with a [Thena to Kustomer migration](https://clonepartner.com/blog/blog/thena-to-kustomer-migration-a-technical-guide/), moving to a CRM-centric platform requires mapping flat conversational data to a strict customer hierarchy. Every Case needs an `AccountId` and `ContactId` — match by email address or company name. Build a status mapping table before you start: Thena Request statuses → Salesforce Case Status picklist values.

**Known transformation failure modes:**
- **Missing Account or Contact match**: If a Thena Account cannot be matched to a Salesforce Account by name or email, you must create a stub Account or the Case load will fail referential integrity checks.
- **Tag-to-picklist mapping**: Thena tags are free-form; Salesforce Case picklist values (Type, Reason, Category) are constrained. Tags not present in the picklist must be added to the picklist definition before load, or the record will fail validation.
- **Thread length**: Thena message arrays can be long. Each message converted to a CaseComment must be under 32KB. Split long messages before load.

If you're creating Assets or Entitlements in Salesforce, this is net-new configuration work — Thena doesn't carry equivalent data. Scope this separately from the data migration itself.

### Step 3: Load into Salesforce

Use the Salesforce Bulk API v2 for record insertion. Load in strict dependency order:

```
1. Accounts (get back Account IDs)
2. Contacts (link to Account IDs)
3. Cases (link to Account IDs + Contact IDs)
4. CaseComments (link to Case IDs)
5. ContentVersion + ContentDocumentLink (link to Case IDs)
6. Knowledge articles (via Knowledge API or Metadata API for complex category structures)
```

> [!CAUTION]
> **Dependency order matters.** Salesforce enforces referential integrity. If you try to load Cases before their parent Accounts exist, every record fails. Map external IDs (Thena Account ID → Salesforce Account ExternalId) and use upsert operations with External ID fields to maintain linkage across load batches. The Bulk API v2 will return job result files listing per-record success/failure — process these before moving to the next dependency layer.

**Knowledge article migration note:** If you're migrating Thena Help Center articles to Salesforce Knowledge, simple content can be loaded via the Knowledge REST API. Articles with complex category hierarchies or publication state requirements must be handled via the Salesforce Metadata API or change sets — the standard data import tools do not support Knowledge category structure.

If Salesforce is already live, Thena's official Salesforce sync can reduce identity cleanup during the transition by pre-syncing accounts and contacts. ([docs.thena.ai](https://docs.thena.ai/platform/apps/salesforce))

Note: Salesforce's Data Import Wizard does not support Case imports. It handles Accounts, Contacts, Leads, and custom objects, capped at 50,000 records. Historical case migrations require Data Loader or Bulk API 2.0. ([help.salesforce.com](https://help.salesforce.com/s/articleView?id=sf.data_import_wizard.htm&language=en_US&type=5))

### Step 4: Rebuild Routing Logic

Do not copy ticket rows and call it done. Thena groups, channel roles, and triage rules do not automatically become Salesforce queues, skills, or Omni-Channel flows. Recreate your routing logic intentionally in the target platform.

### Step 5: Validate and Cut Over

- Run record count reconciliation across all objects
- Verify Case → Account → Contact relationships are intact
- Spot-check conversation threads (CaseComments attached to correct Cases)
- Confirm CaseComment body lengths — any comment exceeding 32KB will have been silently truncated during load; verify the Bulk API v2 result files for failures
- Confirm Omni-Channel routing rules work with migrated Case data
- Test Agentforce (if deployed) against migrated Knowledge articles
- Run both systems in parallel for at least 2 weeks post-migration

For a complete pre-migration checklist, see our [Salesforce Service Cloud Migration Checklist](https://clonepartner.com/blog/blog/salesforce-service-cloud-migration-checklist/).

## When to Choose Which Platform

| Decision Factor | Salesforce Service Cloud | Thena |
|---|---|---|
| Primary support channel | Email, phone, web portal, omnichannel | Slack Connect, MS Teams, Discord |
| CRM dependency | Already using Sales Cloud / Marketing Cloud | No Salesforce dependency |
| Data model complexity | High — needs Assets, Entitlements, cross-object reporting | Low — account + request is sufficient; flat model is a ceiling if complexity grows |
| Team size | 20–500+ agents | 5–50 support staff |
| Budget (per agent/month) | $165–$500+ before add-ons | $29–$119 all-in |
| Implementation timeline | 3–6+ months | Days to weeks |
| AI approach | Agentforce ($2/conversation, 5–11 months setup, requires mature Knowledge library) | Included, AI-native, immediate; limited to conversational data model |
| Compliance needs | Healthcare, government, financial services; HIPAA BAA, FedRAMP, GDPR DPA | B2B SaaS, tech; SOC 2, GDPR DPA on request |
| Integration ecosystem | 3,000+ AppExchange apps | Jira, Linear, Slack, CRM connectors |
| Growth ceiling | Scales to any enterprise complexity | Flat data model limits entitlement/asset workflows |

**Choose Salesforce** if your support data must live in the same database as sales, marketing, and revenue operations — and you have the budget and admin capacity to maintain it.

**Choose Thena** if your customers communicate via Slack Connect, your support team operates independently from sales, and you want AI-native ticket management without a multi-month implementation — and if you are confident your data model requirements will not exceed account + request + tags.

**Neither is universally better.** The worst outcome is buying Salesforce Service Cloud for a team that only needs Slack-based ticketing, or squeezing Thena into a role that requires entitlement-based SLA enforcement and deep CRM relational modeling. Both are architectural decisions with multi-year consequences.

## What Breaks in Real Migrations

These are the specific failure modes that surface consistently when teams move between CRM-heavy and channel-native support platforms:

1. **CaseComment body overflow.** Salesforce's 32KB CaseComment body limit is not enforced during data entry in all cases — but it is enforced on API upsert. Long threads migrated from Thena that exceed 32KB per message will fail silently at the record level in Bulk API v2 result files if you're not checking the error log. Validate message length before load, not after.

2. **Rate limits determine your migration timeline, not your data volume.** Thena's 60 RPM on Standard tier and Salesforce's daily API pool both create bottlenecks. At 60 RPM: 50,000 records = ~14 hours of extraction time before retry overhead. At Salesforce's 150,000 daily REST call budget (50-user Enterprise): a single full re-extraction of Cases + CaseComments + Files can consume the entire daily budget. Plan extraction and loading windows based on actual API math.

3. **Historical conversation threading is the highest-risk transformation.** Slack thread structure, Salesforce CaseComments, EmailMessages, and Chatter FeedItems all represent "conversation" differently. Preserving chronological order and attribution across systems requires custom transformation logic — there is no off-the-shelf connector that handles this correctly for complex orgs.

4. **Attachment handling breaks more migrations than any other step.** In Salesforce, historical attachments can sit behind `ContentVersion`, `ContentDocument`, `ContentDocumentLink`, `EmailMessage`, and the legacy `Attachment` object (for orgs pre-Spring '16). Full file export requires the **Query All Files** permission. Orgs that have been running for 5+ years almost certainly have files across multiple storage mechanisms. Audit before you extract.

5. **Webhook event loss during cutover.** Thena's event-driven architecture depends on Slack webhooks. During cutover, if your routing script takes longer than 3 seconds to return a 200 to Slack, Slack retries 3 times and then drops the event. New tickets created in the final hours before cutover can disappear. Run a reconciliation query against Slack's conversation history API for the cutover window to catch dropped events.

6. **Rollback planning is non-negotiable.** Run both systems in parallel for at least 2 weeks post-migration. Route new tickets to the target platform while keeping the source platform read-only.

If you want to dig deeper into either platform's ecosystem, see our [Ultimate Guide to Salesforce Service Cloud](https://clonepartner.com/blog/blog/ultimate-guide-salesforce-service-cloud-2026/) or our [guide to exporting data from Thena](https://clonepartner.com/blog/blog/how-to-export-data-from-thena-methods-api-limits-formats/).

> Migrating between Salesforce Service Cloud and Thena — or any helpdesk platform? ClonePartner handles the data model translation, API orchestration, attachment mapping, and cutover validation so your team stays focused on support. Book a 30-minute call to scope your migration.
>
> [Talk to us](https://cal.com/clonepartner/meet?duration=30)

## Frequently asked questions

### What is the price difference between Salesforce Service Cloud and Thena in 2026?

Salesforce Service Cloud Enterprise lists at $165/user/month before add-ons that can push it to $400–$600/user/month. Thena ranges from $29/user/month (Starter) to $119/user/month (Enterprise), with AI included in every tier. All plans on both platforms are billed annually.

### Can I run Thena and Salesforce Service Cloud together instead of replacing one?

Yes. Thena's Salesforce app syncs accounts and contacts, supports manual sync plus 4, 8, 12, or 24 hour intervals, and does not auto-delete records in Thena when they are deleted in Salesforce. This hybrid approach keeps Slack-native support in Thena while maintaining CRM data in Salesforce.

### Is Thena a good replacement for Salesforce Service Cloud?

Only if your primary support channel is Slack Connect or MS Teams and your support operation doesn't depend on Salesforce's relational CRM model (Assets, Entitlements, cross-object revenue reporting). Thena cannot replace Salesforce's cross-cloud CRM capabilities, but it delivers faster time-to-value at lower cost for messaging-channel B2B support.

### What are the API rate limits for Thena vs Salesforce Service Cloud?

Thena's Standard tier allows 60 requests/minute per user, org, and IP. Enterprise tier offers custom limits. Salesforce Enterprise Edition starts at 100,000 daily API requests plus 1,000 per user license, with Bulk API capped at 15,000 batches per 24 hours. Both impose constraints that affect migration planning.

### What is the biggest challenge when migrating between Salesforce and Thena?

Data model translation and identity mapping. Salesforce's deeply relational objects (Cases, Contacts, Accounts, Assets, Entitlements, EmailMessages) have no direct structural equivalent in Thena's flat, account-centric model. Every migration requires custom API transformation scripts and field-by-field mapping decisions.