building-sf-integrations

Design Salesforce integration architecture for Named Credentials, External Services, and callouts.

803|289|Updated Nov 7, 2025
One-click install
npx skills add https://github.com/forcedotcom/sf-skills --skill building-sf-integrations
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: building-sf-integrations
Source: https://github.com/forcedotcom/sf-skills/tree/main/skills/building-sf-integrations
Command: npx skills add https://github.com/forcedotcom/sf-skills --skill building-sf-integrations

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires salesforce cli (sf), jq, and includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

building-sf-integrations removes the uncertainty and rework involved in designing secure, production-ready Salesforce integrations by guiding you through the right authentication model, integration pattern, and runtime plumbing for Named/External Credentials, External Services, callouts, and event-driven architectures.

Core Features & Use Cases

  • Integration architecture & runtime plumbing: choose the correct pattern for outbound REST/SOAP callouts, event-driven processing, and CDC-driven replication.
  • Secure credential setup strategy: structure the work around External Credentials and Named Credentials using least-privilege and “no hardcoded secrets” guardrails.
  • Spec-driven integration approach: wire External Services from OpenAPI specs to generate type-safe Apex clients.
  • Operational safety & validation: apply 120-point scoring to enforce timeouts, retry/error handling, bulkification, architecture separation, and documentation quality.
  • Event-driven integration building blocks: outline Platform Events and CDC subscriber considerations including async handling and durability patterns.

Quick Start

Request: "Design a secure, async Salesforce integration that calls Stripe using OAuth Named/External Credentials, and generate the recommended integration architecture and artifacts."

Frequently Asked Questions about building-sf-integrations

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I design a secure Salesforce integration architecture for outbound REST callouts?

To design secure Salesforce integration architecture for outbound REST callouts, use Named Credentials and External Credentials to enforce least-privilege access and eliminate hardcoded secrets. This approach generates a concrete integration plan with required artifacts, scoring validation across security and error handling.

When do I need Change Data Capture and Platform Events for Salesforce integrations?

You need Change Data Capture and Platform Events for Salesforce integrations when building event-driven architectures that require async processing and durability. These patterns outline subscriber considerations and help decide between sync versus async integration models before implementation.

Can I generate Apex clients from OpenAPI specs using External Services in Salesforce?

Yes, you can generate type-safe Apex clients from OpenAPI specs using External Services in Salesforce. This spec-driven integration approach wires OpenAPI definitions directly into your runtime implementation, ensuring type safety and reducing manual callout coding errors.

What's the best way to structure authentication for Salesforce integrations without hardcoded secrets?

The best way to structure authentication for Salesforce integrations without hardcoded secrets is using External Credentials and Named Credentials. This enforces least-privilege guardrails and delegates OAuth setup to related skills, ensuring secure credential management before deployment.

Does this Salesforce integration design approach validate error handling and bulkification patterns?

Yes, this Salesforce integration design approach validates error handling and bulkification patterns through a 120-point scoring system. It enforces operational safeguards including timeouts, retry mechanisms, architecture separation, and documentation quality across your integration implementation.

Do I need the Salesforce CLI and jq to build Salesforce integration architecture plans?

Yes, you need the Salesforce CLI (sf) and jq as dependencies to build Salesforce integration architecture plans. These tools support the generation of required files and artifacts, enabling concrete integration design with scoring-driven validation and clear delegation boundaries.