---
title: "Salesforce vs HubSpot Architecture: The CTO's Technical Guide"
slug: salesforce-vs-hubspot-architecture-the-ctos-technical-guide
date: 2026-06-17
author: Raaj
categories: [Salesforce, HubSpot]
excerpt: "A CTO-level technical comparison of Salesforce and HubSpot architecture, covering data models, API rate limits, Governor Limits, and migration routing."
tldr: Salesforce is a metadata-driven relational platform for complex data models with unlimited custom objects. HubSpot is a unified CRM optimized for speed-to-value. Choose based on engineering capacity.
canonical: https://clonepartner.com/blog/salesforce-vs-hubspot-architecture-the-ctos-technical-guide/
---

# Salesforce vs HubSpot Architecture: The CTO's Technical Guide


Salesforce is a metadata-driven, multi-tenant platform built for deeply relational enterprise data models with unlimited custom objects. HubSpot is a unified single-codebase CRM optimized for speed-to-value with a deliberately constrained data model. Your choice depends on whether you need architectural depth or operational velocity.

## Overview and Core Intent

Salesforce Core CRM uses a metadata-driven, multi-tenant architecture with unlimited custom objects, Junction objects, and Apex server-side code. HubSpot Smart CRM uses a unified single-codebase architecture with flexible object associations and capped custom object definitions on Enterprise. Salesforce optimizes for relational complexity. HubSpot optimizes for time-to-value.

### Ideal Customer Profile

**Salesforce** fits organizations with 3+ dedicated Salesforce engineers (or a certified SI partner), complex multi-object data models, and enterprise-scale compliance requirements. If your org needs Junction objects to model many-to-many relationships across dozens of custom objects, Salesforce is the only viable option.

**HubSpot** fits teams with 0–2 platform engineers who need a CRM operational within days, not quarters. If your data model can be expressed with fewer than 10 custom object types and your primary workflow is marketing-to-sales pipeline management, HubSpot removes the overhead.

**Verdict:** Choose Salesforce if your engineering team builds *on* the platform. Choose HubSpot if your engineering team builds *around* it.

## Architecture and Data Model

### Salesforce: Metadata-Driven Multi-Tenancy

Salesforce runs on a shared-infrastructure, multi-tenant model where every org shares the same database cluster. <cite index="1-9">Due to the multi-tenant nature of the Salesforce platform, different governor limits are introduced to ensure that no customer can monopolize the shared resources.</cite> All customization—fields, objects, layouts, validation rules—is stored as metadata, not as schema changes. Deploying a new custom object does not alter the underlying database schema. It writes metadata rows that the runtime engine interprets at execution time. ([architect.salesforce.com](https://architect.salesforce.com/docs/architect/fundamentals/guide/platform-multitenant-architecture.html))

The data model is highly relational. Salesforce supports unlimited custom objects (with storage-based billing), lookup and master-detail relationships, and **Junction objects** for explicit many-to-many modeling. A Junction object is a custom object with two master-detail fields pointing to two parent objects, giving you full relational control over association attributes.

### HubSpot: Unified Single-Codebase Platform

<cite index="21-6,21-7,21-8">HubSpot CRM data architecture consists of four layers: objects (database tables like Contacts, Companies, Deals), records (individual instances within each object), properties (individual data fields on each record), and associations (relationships connecting records across different objects). This hierarchy determines what is architecturally possible in HubSpot.</cite>

<cite index="20-2,20-3">HubSpot custom objects are available on the Enterprise level subscription plan. An Enterprise level subscription allows for up to ten definitions with up to 500,000 records each without any additional charges.</cite> This is a hard architectural constraint. <cite index="21-9">Custom objects unlock many-to-many relationships that standard objects cannot support, enabling complex data models like subscription tracking, asset management, or multi-location account structures.</cite>

**HubDB** is a separate structured data store designed for CMS content rendering, not CRM operations. HubSpot's own developer guidance positions HubDB for directories, catalogs, and dynamic site pages ([developers.hubspot.com](https://developers.hubspot.com/blog/whats-the-difference-between-hubdb-and-a-custom-object)). It is not a replacement for CRM objects when you need operational workflows, reporting, and record-centric process behavior.

### Impact on Developer Workflow

<cite index="21-10,21-11,21-12,21-13">HubSpot calls them "properties," Salesforce calls them "fields." Salesforce's formula fields map to HubSpot's calculated properties. Salesforce's lookup fields map to HubSpot's associations. One key difference: Salesforce allows creating external ID fields for integration matching, while HubSpot requires unique property constraints or using the record ID.</cite>

Salesforce's deeply nested SOQL relationship queries can return complex object graphs in a single call. HubSpot requires separate association API calls to traverse relationships, increasing the total number of HTTP requests for equivalent data retrieval. In practice, Salesforce lets you keep relationship logic normalized inside the CRM—reducing downstream remodeling but raising query design costs. HubSpot's more uniform APIs reduce setup ceremony, but association-heavy models push join logic into your integration layer.

## Hard Limits, Performance and Scalability

Salesforce enforces per-transaction Governor Limits including a 10-second synchronous Apex CPU cap, 100 SOQL queries per transaction, and 15,000 Bulk API batches per day. HubSpot enforces burst rate limits of 100–190 requests per 10 seconds depending on tier, caps custom object definitions on Enterprise, and throttles workflow execution at scale.

### Salesforce Bottlenecks

<cite index="4-1">Salesforce allows a maximum of 10,000 milliseconds (10 seconds) of CPU time per synchronous Apex transaction and 60,000 milliseconds (60 seconds) per asynchronous Apex transaction.</cite> This is the single most common cause of integration failures during complex data syncs. <cite index="4-5,4-6">CPU time is measured only for processing that occurs on the Salesforce application server. Database operations such as SOQL queries, DML statements, SOSL searches, and the time spent waiting for external API callouts to return are not counted toward the CPU time limit.</cite>

<cite index="2-4">Apex limits the number of SOQL queries that can be executed in a single transaction to 100 for synchronous transactions and 200 for asynchronous transactions.</cite> <cite index="36-1,36-2">The maximum length for a SOQL statement is 100,000 characters.</cite> <cite index="34-2,34-3">Each SOQL query can handle a maximum of 500 junction IDs. Attempting to include more than 500 IDs will result in a "MALFORMED_QUERY" error.</cite>

<cite index="27-1,27-2">Salesforce Bulk API allows up to 15,000 batch submissions per 24 hours, shared between Bulk API 1.0 and 2.0. Each batch can contain maximum 10,000 records with a 10MB payload limit.</cite> Bulk API 2.0 supports larger jobs—up to 150 MB per job—and is designed for operations involving hundreds of thousands to millions of records. <cite index="28-8,28-9">You can process up to 100 million records per 24-hour period using Bulk API 2.0.</cite>

Salesforce also enforces a daily REST/SOAP API allocation. <cite index="53-4,53-5">For Enterprise Edition, the daily API limit starts at 100,000 requests per 24-hour period and increases based on licenses. You can also purchase additional API calls in increments ranging from 200 through 10,000 per 24-hour period.</cite> These daily limits are soft before system protection kicks in, which helps controlled spikes survive. ([developer.salesforce.com](https://developer.salesforce.com/blogs/2024/11/api-limits-and-monitoring-your-api-usage))

> [!WARNING]
> The Apex CPU time limit is the silent killer in Salesforce integrations. A transaction that triggers multiple Apex triggers, workflow rules, and validation rule formula evaluations can hit the 10-second wall even when individual components seem lightweight. Flow, Apex, and package code all share the same transaction budget, so complex automations fail together when CPU time is exhausted.

### HubSpot Bottlenecks

<cite index="9-16">Free and Starter portals allow 100 requests within a 10-second rolling window, while Professional and Enterprise portals allow 190 requests within the same 10-second window.</cite> <cite index="10-1">For apps using OAuth authentication distributed via the HubSpot marketplace, each HubSpot account that installs your app is limited to 110 requests every 10 seconds.</cite>

<cite index="12-16">HubSpot enforces burst limits (100–200 requests per 10 seconds) and daily limits (250,000–1,000,000 per day depending on tier).</cite> The search API is tighter—five requests per second and 200 records per page—which is exactly where naive migration scripts slow down. ([developers.hubspot.com](https://developers.hubspot.com/docs/api/usage-details))

<cite index="24-1">1,000 custom properties per object is a technical limit.</cite> <cite index="51-5">There is a 100,000 log limit for successful workflow executions per day.</cite> High-volume automation scenarios—large list enrollments, bulk imports triggering workflows—can silently stop logging.

Custom code actions in workflows run in a managed serverless environment with a **20-second execution timeout** and 128 MB of memory. HubSpot Enterprise accounts can create up to 1,000 workflows. <cite index="50-1">Aside from the email frequency safeguard, there are not any native options for throttling or limiting workflow performance.</cite> A bulk import can trigger thousands of workflow executions simultaneously, hammering downstream APIs.

> [!NOTE]
> If your sync design depends on one API lookup per record and one workflow side effect per write, HubSpot throttles show up fast. If your design depends on synchronous Apex or record-triggered automation during bulk loads, Salesforce CPU and query limits show up fast. Design for the platform's bottleneck, not just its feature list.

## Feature-by-Feature Engineering Comparison

### Customization and Extensibility

**Winner: Salesforce**

Salesforce offers Apex (a strongly-typed, Java-like language) for server-side logic, Visualforce for legacy UI rendering, and Lightning Web Components (LWC) for modern frontend development. You can write custom REST endpoints, scheduled batch jobs, and database triggers with full transactional control.

HubSpot offers HubL (a Jinja-like templating language) for CMS rendering and UI Extensions (React-based) for CRM record pages. Server-side logic is limited to Operations Hub custom code actions (Node.js or Python with a 20-second execution timeout). You cannot write database triggers or custom API endpoints natively.

**Caveat:** Salesforce's power comes with complexity. An improperly written Apex trigger can cascade Governor Limit violations across your entire org. HubSpot's constraints prevent this class of failure entirely. The narrower model is often a feature for teams that want to stop CRM drift before it becomes a custom software estate.

### Automation Architecture

**Winner: Tie — Salesforce for depth, HubSpot for speed**

Salesforce Flow supports record-triggered flows, scheduled flows, screen flows, and auto-launched flows with full conditional branching, loops, and subflows. Flows can call Apex actions for operations that exceed declarative capabilities. The catch: flows, triggers, and package code all share the same transaction budget, so complex automations fail together when CPU time is exhausted.

HubSpot Workflows support contact, company, deal, ticket, and custom object enrollment with branching, delays, and webhook actions. The single-codebase architecture ensures that marketing, sales, and service automations share the same context without integration latency. But custom code actions inherit strict runtime and memory ceilings, and there is no native throttling for workflow execution during bulk operations.

**Caveat:** The more business logic you embed in Salesforce, the harder it becomes to bulk load, regression test, and migrate. The more you keep HubSpot logic simple, the easier it is to operate—but the sooner you reach a ceiling where external services must own the hard logic.

### Advanced Reporting and Analytics

**Winner: Salesforce**

Salesforce provides native report types, cross-object reporting, custom report types, and Einstein Analytics (Tableau CRM) for advanced BI. Data can be exported via Bulk API 2.0 or streamed via Change Data Capture (CDC) into external data warehouses. The metadata structure allows for highly complex dimensional reporting across dozens of joined tables.

HubSpot offers standard and custom reports with cross-object filtering. <cite index="21-15,21-16">Content Assistant pulls property values from standard objects only. It cannot personalize emails using custom object properties.</cite> Custom object reporting has limited support in several HubSpot tools, creating blind spots for teams with complex data models. If your main goal is low-friction ETL rather than in-platform analytics depth, HubSpot becomes the simpler engineering choice.

| Category | Winner | Technical Rationale | Caveat |
|---|---|---|---|
| Customization and Extensibility | Salesforce | Apex, LWC, custom REST endpoints, database triggers | High technical debt and Governor Limit exposure |
| Automation Architecture | Tie | Salesforce wins on depth, HubSpot wins on speed | Both hit ceilings under bulk load |
| Reporting and Analytics | Salesforce | Cross-object reporting, CDC streaming, Tableau CRM | Requires SOQL expertise and careful limit management |

## True Total Cost of Ownership and Hidden Costs

### Salesforce Monetization Model

Salesforce charges **per seat per month** with edition-based feature gating. Enterprise Edition starts around $165/user/month (billed annually). <cite index="53-4,53-5">For Enterprise Edition, the daily API limit starts at 100,000 requests per 24-hour period and increases based on licenses.</cite> API access is included on Enterprise, but features like CPQ, advanced analytics, and full-copy sandboxes require separate licenses or higher editions.

Hidden costs include:

- **Consulting and SI fees:** Complex implementations typically require certified Salesforce consulting partners. Enterprise teams with heavy customization budget for SI help, regression testing, and storage management because the platform behaves like a software estate.
- **AppExchange add-ons:** Features like CPQ, advanced analytics, and document generation often live in paid third-party packages.
- **Data storage overages:** Base storage allocations (10 GB plus user-based increments) fill fast in orgs with attachments and file-heavy workflows.
- **Premier Support:** Priced at 30% of net license fees. ([salesforce.com](https://www.salesforce.com/services/pricing/?bc=OTH))

### HubSpot Monetization Model

HubSpot uses **contact-tier and hub-bundle pricing**. You pay based on the number of marketing contacts and which Hubs (Marketing, Sales, Service, Operations, CMS) you enable. Enterprise tier pricing varies, but scales with contact volume and hub selection.

Hidden costs include:

- **Enterprise-only custom objects:** Teams migrating from Salesforce with relational data models must upgrade to Enterprise or flatten their schema.
- **Contact-tier overages:** Marketing contact growth compounds costs even when seat count stays flat.
- **Operations Hub requirement:** Building custom webhooks or complex data formatting logic often requires upgrading to Operations Hub Professional or Enterprise.
- **API limit increases:** Higher throughput for integrations may require purchased limit increases beyond the default daily cap.

> [!NOTE]
> The biggest hidden cost in both platforms is not licensing. It is the engineering time spent working around platform constraints. A Salesforce org with poorly designed triggers can consume months of debugging effort. A HubSpot instance that outgrows its custom object ceiling forces architectural redesign or migration.

## Integration Topology and Developer Experience

### API Surface

Salesforce's API surface is the broadest in CRM. REST and SOAP share the same daily call pool. <cite index="55-19,55-20">Bulk API 2.0 was designed for operations involving thousands to millions of records.</cite> <cite index="55-22">Bulk API calls do not count against your standard daily API call limit in the same way.</cite> Salesforce also offers Change Data Capture for real-time event streaming, Platform Events for pub/sub messaging, and a Pub/Sub API that streams events over gRPC with 72-hour event retention. ([developer.salesforce.com](https://developer.salesforce.com/docs/platform/pub-sub-api/guide/intro.html))

HubSpot's REST API is well-documented and consistent. Standard and custom objects share the same API patterns, reducing adapter code and onboarding time. Most REST APIs moved to date-based versioning in March 2026. HubSpot also supports a GraphQL API that can query CRM and HubDB data, though CRM queries cap at 500 items with aggregate complexity limits. There is no native bulk data API equivalent—large data operations must be broken into batched REST calls respecting burst limits.

**Developer experience verdict:** HubSpot has the easier ramp. Salesforce has the deeper bench once ramped.

### Webhooks and Real-Time Streaming

Salesforce supports outbound messaging (SOAP-based), Platform Events, and Change Data Capture for real-time data streaming. CDC publishes change events for standard and custom objects to an event bus that external subscribers can consume and replay within the retention window.

HubSpot supports webhook subscription actions within workflows and a webhook API for app-level event notifications. There is no native event bus or CDC equivalent. Real-time sync requires polling the API or relying on workflow-triggered webhooks, which are subject to the workflow execution limits above. Production-grade sync still needs idempotency, replay handling, and periodic reconciliation because webhooks are notifications, not full state transfer.

### Authentication

HubSpot's private app model with OAuth and scoped API tokens takes minutes to configure. Salesforce requires connected app configuration, and depending on the integration pattern, may need JWT bearer flows, certificates, or SOAP WSDL generation. The setup overhead is real.

## Data Portability and Complex Migration Routing

### Bulk Data Extraction

Salesforce data extraction at scale is straightforward via Bulk API 2.0. You can query any standard or custom object and retrieve results as CSV. <cite index="28-8,28-9">You can process up to 100 million records per 24-hour period using Bulk API 2.0.</cite> Attachments and files require separate ContentDocument/ContentVersion queries. Salesforce also supports Change Data Capture for ongoing incremental warehouse sync.

HubSpot bulk extraction requires paginated REST API calls. There is no dedicated bulk export API. For large datasets, you must manage cursor-based pagination across multiple objects. File attachments (engagements, notes) require separate API calls per record. The simpler schema reduces complexity in extraction logic, but the rate limits make large-scale extraction significantly slower than Salesforce's Bulk API path.

For a detailed walkthrough of Salesforce export constraints, see our guide on [how to export data from Salesforce Service Cloud](https://clonepartner.com/blog/blog/how-to-export-data-from-salesforce-service-cloud-methods-limits/).

### Migration Pathway: Salesforce to HubSpot

The technical migration path involves four phases:

1. **Schema mapping:** Map Salesforce custom objects, Junction objects, and lookup relationships to HubSpot's association model. Any Salesforce org with more than 10 custom object types forces hard decisions about flattening or consolidating objects.
2. **Data extraction:** Use Bulk API 2.0 for record data. Use ContentDocument queries for attachments. Export metadata (field definitions, picklist values, record types) via the Metadata API.
3. **Transformation:** Convert Salesforce record type patterns to HubSpot pipeline stages. Map picklist values to dropdown properties. Restructure Junction object data into HubSpot many-to-many associations.
4. **Load and validation:** Batch-import into HubSpot respecting rate limits. Validate association integrity, attachment linkage, and property value mapping. Recreate automation logic manually—Apex, validation rules, assignment logic, and Flow do not port one-to-one into HubSpot Workflows.

```yaml
salesforce_to_hubspot:
  Account: Company
  Contact: Contact
  Opportunity: Deal
  Junction__c: custom object or labeled association
```

For a step-by-step breakdown of this pathway, see our [Salesforce to HubSpot migration guide](https://clonepartner.com/blog/blog/salesforce-to-hubspot-migration-pipeline-tickets-attachments/).

> [!TIP]
> Do not hard-cutover between Salesforce and HubSpot. Run both in parallel during the transition period to validate data integrity under live conditions. We cover this approach in depth in our guide on [why running two CRMs in parallel beats a hard cutover](https://clonepartner.com/blog/blog/why-running-two-crms-in-parallel-beats-a-hard-cutover/).

### Vendor Lock-In Risk

**Salesforce** lock-in lives in Apex code, Lightning Web Components, Flow configurations, and metadata-driven business logic. Your data is extractable via Bulk API. Your logic layer is not portable.

**HubSpot** lock-in lives in workflow configurations, HubL templates, and the association model. The data itself is extractable via API, but workflow logic and CMS content built on HubL have no external equivalent.

Both platforms create significant technical debt in their automation and UI layers. Data portability is comparable. Logic portability is near-zero for both. Salesforce debt is typically harder to unwind once deeply customized because more business behavior lives inside the platform.

## Core Strengths and Fatal Flaws

### Salesforce Strengths

- **Change Data Capture (CDC):** Real-time event streaming for any object change, enabling true event-driven architectures with external systems without polling.
- **Metadata API programmatic deployment:** Full CI/CD pipeline support via SFDX and Metadata API. You can version-control your entire org configuration including custom objects, fields, flows, and permission sets.
- **Multi-currency and multi-entity native support:** Built-in dated exchange rates, advanced currency management, and territory management that HubSpot cannot replicate without external tooling.
- **Relational depth:** Unlimited custom objects and Junction objects for complex many-to-many modeling are first-class patterns, not workarounds.
- **Bulk extraction at scale:** Bulk API 2.0 and Pub/Sub API give separate paths for historical backfill and near real-time change capture.

### Salesforce Fatal Flaws

- **Governor Limit cascade failures:** A single poorly written trigger can cause org-wide transaction failures that are extremely difficult to diagnose in production. Flow, Apex, and package code share the same CPU budget.
- **Sandbox parity drift:** Full-copy sandboxes are only available on higher-tier editions. Partial sandboxes frequently drift from production, making testing unreliable.
- **Licensing complexity:** Feature availability varies by edition (Professional, Enterprise, Unlimited) in non-obvious ways. API access is not available on all editions without add-ons.
- **Technical debt accumulation:** Metadata freedom creates migration debt because business behavior lives in config, automation, and integrations—not only in records.

### HubSpot Strengths

- **Time-to-value on integrations:** The private app model with OAuth and scoped API tokens takes minutes to configure. No connected app certificates, no JWT bearer flows.
- **Native marketing and CMS unification:** Website analytics, email marketing, landing pages, and CRM records share a single data layer. No integration required between marketing automation and CRM.
- **Predictable API contract:** HubSpot's REST API follows consistent patterns across all objects. Endpoint structure, pagination, and error handling are uniform, reducing integration development time.
- **Date-based API versioning:** A cleaner upgrade story for new integrations compared to Salesforce's API surface.

### HubSpot Fatal Flaws

- **Custom object ceiling:** Enterprise plans cap custom object definitions. Organizations with complex domain models hit this wall fast, and there is no workaround other than purchasing additional capacity.
- **No bulk data API:** Large-scale data operations are throttled by burst rate limits. A 500,000-record migration at 190 requests per 10 seconds (batch endpoint, 100 records per batch) takes hours of carefully throttled API calls.
- **Workflow execution opacity:** <cite index="51-4,51-5">Historical data for enrollments is stored in HubSpot for 6 months. There is a 100,000 log limit for successful workflow executions per day.</cite> At scale, you lose visibility into what your automations actually did.
- **Relational rigidity:** Flattened data models struggle to replicate deep enterprise database schemas. Association-heavy models push join logic into your integration layer.

## Final Architectural Decision Matrix

### Choose Salesforce if:

- Your data model requires more than 10 custom object types
- You need Junction objects for many-to-many relationship attributes
- Your team includes certified Salesforce developers or a dedicated SI partner
- You require Change Data Capture for real-time data warehouse streaming
- Multi-currency, multi-entity, or territory management is a business requirement
- You need Apex server-side logic for complex validation or integration orchestration

### Choose HubSpot if:

- Your data model fits within HubSpot's custom object and workflow ceilings
- Your priority is marketing-to-sales pipeline velocity over data model depth
- You have 0–2 platform engineers and need to be operational in days
- Your integration needs are solved by REST API and webhook-based patterns
- You want native CMS, email marketing, and CRM in a single data layer
- You prefer predictable contact-based pricing over per-seat licensing

### The CTO Summary

Salesforce is an enterprise-grade relational database platform with a CRM built on top. HubSpot is a CRM with a deliberately constrained data model designed for operational speed. The wrong choice is not picking the inferior platform—it is picking the platform that does not match your engineering capacity.

If your technical team builds complex data models, writes server-side code, and needs event-driven architecture, Salesforce is the correct choice despite its higher engineering overhead. If your team needs a CRM that works out of the box with minimal platform engineering, and your data model is not deeply relational, HubSpot gets you there faster and cheaper. The best platform is the one your actual team can still operate cleanly in year two.

For a broader look at how HubSpot compares to other modern CRMs, see our [HubSpot vs GoHighLevel technical comparison](https://clonepartner.com/blog/blog/hubspot-vs-gohighlevel-2026-the-ctos-technical-comparison/).

> Planning a Salesforce to HubSpot migration (or the reverse)? ClonePartner handles Junction object mapping, Bulk API rate limits, and parallel CRM sync so your team stays focused on product. Book a 30-minute technical scoping call.
>
> [Talk to us](https://cal.com/clonepartner/meet?duration=30)

## Frequently asked questions

### Which CRM handles complex relational data better, Salesforce or HubSpot?

Salesforce handles complex relational data better. It supports unlimited custom objects, Junction objects for explicit many-to-many relationships, and deeply nested SOQL queries across up to 55 child-to-parent relationships. HubSpot caps custom objects on Enterprise and uses a flatter association model that cannot represent complex entity hierarchies without significant schema compromise.

### What are the exact API rate limits for HubSpot compared to Salesforce?

HubSpot enforces 100 requests per 10 seconds (Free/Starter) or 190 per 10 seconds (Pro/Enterprise) as burst limits, with daily caps of 250,000 to 1,000,000 calls depending on tier. Salesforce allows 100,000+ daily REST/SOAP calls (Enterprise Edition, scaling with licenses) plus 15,000 Bulk API batches per day with 10,000 records per batch. Bulk API 2.0 supports processing up to 100 million records per 24-hour period.

### Which platform is easier to migrate data out of for a custom data warehouse?

Salesforce has superior extraction tooling—Bulk API 2.0 supports querying up to 100 million records per day as CSV, and Change Data Capture enables ongoing incremental sync. HubSpot's simpler schema and uniform APIs reduce extraction complexity, but the lack of a bulk export API and strict rate limits make large-scale extraction significantly slower.

### What is the Salesforce Apex CPU time limit?

Salesforce enforces a 10,000-millisecond (10-second) CPU time limit per synchronous Apex transaction and 60,000 milliseconds (60 seconds) per asynchronous transaction. CPU time only counts application server processing—database operations and API callout wait times are excluded.

### Are HubSpot custom objects available on all plans?

No. HubSpot custom objects are restricted to Enterprise-tier subscriptions only. The number of custom object definitions and total records are capped. Teams on Professional or lower plans must use standard objects or upgrade to model relational data.