OpenParable
Skip to content
← Back to skills

Salesforce Cost Tuning

Business
salesforce-cost-tuning

Salesforce Cost Tuning is an Agent Skill for business published in the jeremylongshore/claude-code-plugins-plus-skills repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Optimize Salesforce costs through API call reduction, edition selection, and license management. Use when analyzing Salesforce costs, reducing API consumption, or choosing the right Salesforce edition for your integration needs. Trigger with phrases like "salesforce cost", "salesforce pricing", "reduce salesforce costs", "salesforce license", "salesforce API usage", "salesforce budget".

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/jeremylongshore/claude-code-plugins-plus-skills/blob/HEAD/plugins/saas-packs/salesforce-pack/skills/salesforce-cost-tuning/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/salesforce-cost-tuning, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

Salesforce Cost Tuning

Overview

Optimize Salesforce costs by reducing API call consumption, choosing the right edition, and monitoring API usage budgets. Salesforce charges per-user licenses (not per-API-call), but API limits are tied to edition + license count.

Prerequisites

  • Access to Salesforce Setup > Company Information
  • Understanding of current API usage patterns
  • Access to contract/license details

Instructions

Step 1: Understand Salesforce Pricing Model

EditionPer-User/MonthAPI Calls/Day (Base)Per-User API Calls
DeveloperFree15,000N/A (1 user)
Essentials~$2515,000+1,000/user
Professional~$8015,000+1,000/user
Enterprise~$165100,000+1,000/user
Unlimited~$330100,000+5,000/user
API Add-on PackVaries+200K-10M/dayPer org

Key insight: API calls are per-org, not per-user. A 50-user Enterprise org gets 100,000 + (50 * 1,000) = 150,000 daily API calls. All integrations share this pool.

Step 2: Monitor Current Usage

const conn = await getConnection();
const limits = await conn.request('/services/data/v59.0/limits/');

const apiUsage = {
  daily: {
    used: limits.DailyApiRequests.Max - limits.DailyApiRequests.Remaining,
    remaining: limits.DailyApiRequests.Remaining,
    max: limits.DailyApiRequests.Max,
    percentUsed: ((limits.DailyApiRequests.Max - limits.DailyApiRequests.Remaining) / limits.DailyApiRequests.Max * 100).toFixed(1),
  },
  bulk: {
    ingestJobs: limits.DailyBulkV2QueryJobs,
    queryJobs: limits.DailyBulkV2QueryJobs,
  },
  storage: {
    dataMB: `${limits.DataStorageMB.Max - limits.DataStorageMB.Remaining}/${limits.DataStorageMB.Max} MB`,
    fileMB: `${limits.FileStorageMB.Max - limits.FileStorageMB.Remaining}/${limits.FileStorageMB.Max} MB`,
  },
};

console.log('API Usage:', JSON.stringify(apiUsage, null, 2));

Step 3: Reduce API Call Count (Biggest Cost Lever)

// BEFORE: 1 API call per record = expensive
for (const contact of contacts) {
  await conn.sobject('Contact').create(contact); // 1000 calls for 1000 records
}

// AFTER: Batch with sObject Collections = 5 calls for 1000 records
for (let i = 0; i < contacts.length; i += 200) {
  const batch = contacts.slice(i, i + 200);
  await conn.sobject('Contact').create(batch); // Max 200 per call
}

// AFTER: Use Bulk API for 10K+ records = 1 job regardless of count
await conn.bulk2.loadAndWaitForResults({
  object: 'Contact',
  operation: 'insert',
  input: csvData, // Can be millions of rows
});
// Bulk API has its own separate daily limit (15,000 jobs)

// Cache describe calls — saves 50+ calls/day if you describe objects frequently
const describeCache = new Map();
async function cachedDescribe(objectName: string) {
  if (!describeCache.has(objectName)) {
    describeCache.set(objectName, await conn.sobject(objectName).describe());
  }
  return describeCache.get(objectName);
}

Step 4: API Call Budget Tracking

class ApiCallBudget {
  private dailyBudget: number;
  private callsToday = 0;

  constructor(dailyBudget: number) {
    this.dailyBudget = dailyBudget;
  }

  async refreshFromOrg(conn: jsforce.Connection): Promise<void> {
    const limits = await conn.request('/services/data/v59.0/limits/');
    this.callsToday = limits.DailyApiRequests.Max - limits.DailyApiRequests.Remaining;
    // Note: this call itself costs 1 API call — don't check too frequently
  }

  canSpend(estimatedCalls: number): { allowed: boolean; reason?: string } {
    const projected = this.callsToday + estimatedCalls;

    if (projected > this.dailyBudget * 0.95) {
      return { allowed: false, reason: `Would exceed 95% of ${this.dailyBudget} daily budget` };
    }

    if (projected > this.dailyBudget * 0.80) {
      console.warn(`API budget warning: ${this.callsToday}/${this.dailyBudget} used`);
    }

    return { allowed: true };
  }
}

Step 5: Edition Right-Sizing

Decision tree for Salesforce edition:

If API calls/day < 15,000:
  → Developer Edition (free) or Professional ($80/user/month)

If API calls/day 15,000-150,000:
  → Enterprise Edition ($165/user/month)

If API calls/day > 150,000:
  → Unlimited ($330/user/month) or API Add-on Pack
  → OR reduce calls with batching/caching (usually cheaper)

If you need just data sync:
  → Consider Heroku Connect ($$$) for automatic bi-directional sync
  → Eliminates most API calls — data syncs via Change Data Capture

Output

  • Current API usage analyzed
  • Cost reduction strategies applied (batching, caching, Bulk API)
  • API call budget tracking implemented
  • Edition recommendation based on usage

Error Handling

IssueCauseSolution
Unexpected API call spikeUnoptimized loop/queryUse Collections or Bulk API
Budget exceededMissing monitoringAdd budget tracking class
Storage limitToo many records/filesArchive old data, delete test data
License overspendUnused integration licensesAudit active users quarterly

Resources

Next Steps

For architecture patterns, see salesforce-reference-architecture.