95 terms across CRM, CPQ, Revenue Cloud, integration and AI — defined in plain English by engineers who build on the platform daily. Every entry is self-contained, so you can cite or link any definition on its own.
Salesforce’s framework for building and running AI agents that operate on CRM data. An agent is configured with topics, instructions and actions — Flows, Apex, prompts or APIs it may invoke — plus guardrails that bound its behavior. Unlike scripted chatbots, agents plan multi-step work autonomously within those boundaries. Rolling one out well is an engineering project; this Agentforce implementation guide covers a grounded approach.
A software system that uses a large language model to decide which actions to take toward a goal, rather than following a fixed script. Agents combine reasoning, tool calls — APIs, database queries, business actions — and memory, operating within constraints set by their builders. In a CRM context, agents draft replies, qualify leads, book meetings and update records, escalating to humans when confidence drops.
Salesforce’s proprietary, strongly typed, Java-like programming language that runs on the platform’s servers. Apex powers triggers, asynchronous jobs, web services and business logic that declarative tools cannot express cleanly. Because it executes in a multi-tenant environment, Apex is subject to governor limits that cap queries, DML and CPU time per transaction. Well-structured Apex follows bulkified, testable patterns — see these Apex best practices.
Apex code that fires automatically before or after records are inserted, updated, deleted or undeleted. Triggers enforce logic that must never be bypassed, such as validation across objects or downstream synchronization. Good practice keeps one trigger per object, delegating to handler classes and processing records in bulk. Whether logic belongs in a trigger, a Flow or elsewhere is an architectural decision — see when to write Apex.
Salesforce’s official marketplace for third-party applications, components and consulting partners. Apps are distributed mainly as managed packages that install into an org, and every listed product passes a Salesforce security review before publication. Buyers evaluate apps on feature fit, security posture, support terms and total cost against building in-house. Consultancies also maintain AppExchange listings, which is a useful signal of a vetted partner.
Apex that runs in the background rather than inside the user’s transaction. The main flavors are future methods, Queueable jobs, Batch Apex and Scheduled Apex. Asynchronous execution gets higher governor limits and keeps long-running work — callouts, mass updates, nightly jobs — out of the interactive path. The trade-off is eventual rather than immediate consistency, plus the need for deliberate error handling and retries.
An asynchronous Apex construct for processing large data volumes in chunks, up to fifty million records per job via a query locator. A batch class defines start, execute and finish methods; the platform splits the record scope into batches and runs them sequentially. Use it for mass recalculation, archival and cleanup. Each chunk gets fresh governor limits, but jobs share org-wide asynchronous quotas, so scheduling matters.
The invoicing layer of Salesforce’s revenue stack. It converts orders and subscription terms into invoices, applies taxes and payments, and posts financial data to downstream ERP or accounting systems. Billing rules govern when and how charges are invoiced — one-time, recurring or usage-based. In the Revenue Cloud generation of products, billing sits at the end of the quote-to-cash chain, after catalog, pricing and orders.
A REST-based Salesforce API optimized for loading or extracting very large record volumes asynchronously. Jobs are submitted, processed in batches server-side, then polled for results, which suits data migration and nightly synchronization far better than record-at-a-time calls. Bulk API 2.0 simplifies batch management. Watch for locking contention on shared parent records, and plan load ordering carefully when inserting related objects.
A Salesforce streaming feature that publishes change events whenever records are created, updated, deleted or undeleted. Subscribers — middleware, external services or other Salesforce code — receive near-real-time notifications carrying the changed field values, enabling synchronization without polling. CDC events travel over the same event bus as Platform Events, with retention windows and delivery allocations to plan around. A cornerstone of event-driven integration patterns.
Continuous integration and continuous delivery: merging changes frequently, verifying every change with automated builds and tests, and deploying through a repeatable pipeline. On Salesforce this means source-tracked metadata in version control, scratch orgs or sandboxes per stage, automated Apex tests and static analysis, and gated promotion to production. Code review is the human complement to those automated gates.
Salesforce’s e-commerce product family covering B2C and B2B storefronts. It provides catalog, cart, checkout, promotions and order capture, delivered either as templated storefronts or as headless APIs consumed by a custom front end. B2B Commerce runs on the core platform and shares data with CRM objects, which simplifies quote-to-order flows. Evaluate whether templated or headless architecture fits the brand experience — see Salesforce Commerce Cloud.
A Salesforce REST API that bundles several dependent operations into one round trip. A composite request can create a parent record and children referencing its new ID, or mix queries and DML, and can execute all-or-nothing. It reduces API call counts and network latency for integrations that would otherwise chain many requests, at the cost of more careful error handling in the composite response body.
The API surface — also called Chatter REST API, with an Apex counterpart named ConnectApi — that exposes Salesforce collaboration and platform features: feeds, communities, files, recommendations and, increasingly, commerce and CMS capabilities. In Apex, ConnectApi classes give strongly typed access to functionality that would otherwise require HTTP callouts to the org’s own REST endpoints. It appears often in Experience Cloud and B2B Commerce development.
A Salesforce configuration record that lets an external application authenticate and call the org’s APIs, defining OAuth scopes, callback URLs, certificates and policies such as IP restrictions and session duration. Every integration client — middleware, mobile app, CI pipeline — should have its own connected app so access can be monitored and revoked independently. External client apps are the newer, packageable evolution of the concept.
Configure, Price, Quote: software that helps sales teams assemble valid product configurations, price them correctly and produce accurate quotes. CPQ enforces product rules, discount approvals and pricing logic that spreadsheets cannot. Salesforce CPQ is the long-standing managed-package product; the newer Revenue Cloud rebuilds the capability natively. How pricing behaves in real deals is where CPQ projects are won or lost.
Customer relationship management: the discipline, and the software category, for managing interactions with customers and prospects across marketing, sales and service. A CRM system centralizes accounts, contacts, deals and cases so every team shares one view of the customer. Salesforce is the largest CRM platform; its value compounds when surrounding processes — quoting, orders, billing, support — run on the same data model.
A Salesforce feature for defining configuration data that deploys like metadata. Records of a custom metadata type — rate tables, endpoint settings, feature flags — migrate between orgs in packages and pipelines instead of being re-keyed by hand. Apex can read them without consuming SOQL query limits against data rows. Prefer them over custom settings when configuration should be versioned and deployable.
A database table you define on the Salesforce platform, with fields, relationships, page layouts and security, sitting alongside standard objects like Account and Opportunity. Custom objects carry the domain-specific data a business needs — policies, shipments, subscriptions. Each object automatically gets APIs, reporting and automation hooks. Data-model decisions here echo for years, so make them deliberately before volume and integrations arrive.
Salesforce’s customer data platform, which ingests, harmonizes and unifies data from CRM, web, mobile, warehouses and streams into unified profiles. It resolves identities across sources, computes calculated insights and segments, and activates them in CRM, marketing and agent grounding. Zero-copy federation can query external warehouses without duplicating data. Treat Data Cloud as a data engineering project, not a feature toggle.
Salesforce’s client tool for bulk inserting, updating, upserting, deleting and exporting records via CSV files. It suits one-off loads and simple recurring jobs; larger or repeatable migrations usually graduate to Bulk API scripts or ETL tools with proper transformation, logging and retry logic. Always rehearse loads in a sandbox first, and match records on external IDs rather than names.
The process of moving data from legacy systems into a new platform: profiling sources, mapping fields, transforming values, de-duplicating, loading and validating. On Salesforce, migrations must respect object relationships, ownership, picklist values and automation side effects during load. A rehearsed, scripted migration with reconciliation counts is the difference between a clean cutover and months of mistrust in the data.
A Salesforce performance anti-pattern in which too many child records point at one parent, or one owner holds an outsized share of records — commonly beyond tens of thousands. Skew causes lock contention during loads, slow sharing recalculation and query hot spots. Mitigations include distributing ownership, avoiding lookups to a single generic parent, and batching updates so parent row locks are not held concurrently.
Salesforce’s free release-management tool that replaces change sets with source control. It tracks metadata changes as work items, commits them to a Git repository and promotes them through a defined pipeline of environments. It lowers the entry barrier to versioned delivery for admin-heavy teams, and it coexists with the more advanced CI/CD tooling engineering teams typically run alongside it.
The umbrella brand for AI capabilities across Salesforce products: predictive scoring, forecasting, recommendations, and generative features such as drafting emails or summarizing cases. Einstein spans point-and-click predictions through platform services for custom models and prompts. Which capabilities are included versus separately licensed changes frequently, so verify against current Salesforce documentation. Practical AI use cases matter more than the branding.
The security architecture between Salesforce generative AI features and large language models. It grounds prompts with CRM data, masks sensitive fields before a prompt leaves the platform, enforces zero-retention agreements with model providers, scans outputs for toxicity, and writes an audit trail of AI interactions. It exists so regulated businesses can use language models without their data training external models.
An integration architecture in which a central bus handles routing, transformation, protocol mediation and orchestration between systems, replacing point-to-point links. Producers publish to the bus; consumers subscribe or receive routed messages. ESBs bring governance and reuse, but they can become bottlenecks or single points of failure when every integration funnels through one heavyweight layer. Modern landscapes often blend ESB, iPaaS and event streaming.
Extract, transform, load: the batch pattern for moving data between systems. Data is pulled from sources, reshaped — cleaned, joined, mapped — and written to a target such as a warehouse or CRM. ELT variants land raw data first and transform inside the target. ETL remains the workhorse for migrations, nightly synchronization and analytics feeds where latency of minutes to hours is acceptable.
An integration style in which systems communicate by publishing and subscribing to events rather than calling each other directly. Producers emit facts — order placed, payment failed — and any number of consumers react independently. This decouples systems, absorbs traffic spikes and enables real-time reactions, at the cost of eventual consistency and harder end-to-end tracing. Salesforce participates through Platform Events and Change Data Capture.
Salesforce’s platform for building authenticated portals and public sites on CRM data: customer communities, partner portals, help centers and self-service applications. Sites reuse the org’s objects, sharing rules and automation, with licensing per member or per login. Because external users touch real CRM data, sharing and security configuration deserve as much attention as the visual build — see Experience Cloud.
Salesforce objects whose data lives outside the org and is fetched on demand through Salesforce Connect, typically over OData or a custom Apex adapter. Records appear in lists, related lists and searches without being copied into Salesforce, which avoids synchronization pipelines for reference data such as ERP invoices. Trade-offs include callout latency, limited reporting and dependence on the remote system’s availability.
A Salesforce feature that imports an OpenAPI specification of a REST service and generates invocable actions from it. Declarative builders can then call the external API from Flow without custom Apex, with typed inputs and outputs. It suits well-defined, stable APIs; complex authentication flows, large payloads or unusual response shapes still tend to justify hand-written Apex callouts instead.
The Salesforce control determining which fields a user can see or edit, layered beneath page layouts and above object permissions. FLS is granted through profiles and permission sets, and modern Apex must respect it explicitly with security-enforced queries or permission checks. Auditing FLS is a standard part of a security review, because one exposed field can leak sensitive data org-wide.
A Salesforce industry product for banks, insurers and wealth managers that extends CRM with a financial data model: households, financial accounts, policies, claims and relationship groups. It adds industry console applications and compliance-oriented features on top of the core platform. Firms connecting it to core banking systems should plan the API architecture early — that integration usually dominates the effort.
Salesforce’s declarative automation tool for building logic without code: record-triggered automation, scheduled jobs, guided screen wizards and autolaunched subflows. Flow has largely replaced Workflow Rules and Process Builder. It handles conditional logic, loops and callouts through invocable actions, within its own execution limits. Knowing when a requirement outgrows Flow and belongs in Apex is a recurring architecture decision.
Per-transaction resource caps the Salesforce platform enforces so no tenant can monopolize shared infrastructure: limits on SOQL queries, DML statements, CPU time, heap size, callouts and more. Exceeding a limit throws an uncatchable exception and rolls the transaction back. They are design constraints, not bugs — bulkified code, selective queries and asynchronous offloading are the standard disciplines for staying within them.
A CPQ technique that leads sellers through questions about customer needs and derives a valid product configuration from the answers, instead of exposing the full catalog. It shortens ramp time for new reps, reduces invalid quotes and encodes product expertise into rules. Effective guided selling depends on a well-modeled catalog — this complex CPQ playbook covers the underlying design patterns.
An architecture in which CRM data and logic are consumed exclusively through APIs while user experiences are built in external front ends — web applications, mobile, kiosks. The CRM becomes a system of record and process engine rather than a user interface. The approach suits product-led companies with strong front-end teams, and it stresses API design, authentication and latency budgets. See headless CRM on Salesforce for the trade-offs.
A structured assessment of an existing Salesforce implementation: security posture, technical debt, automation sprawl, data quality, integration reliability, performance and release process. The useful output is a prioritized findings list with effort estimates, not a generic score. Salesforce’s built-in Security Health Check covers baseline settings; a full org health check goes well beyond it into architecture, code and process.
Salesforce’s infrastructure architecture that runs the platform on public cloud providers instead of Salesforce-managed data centers. For customers it mainly means regional data-residency options, elastic scaling and alignment with public cloud compliance regimes. Application behavior is intended to be unchanged, but integration teams should re-verify IP allowlists, certificates and connectivity assumptions when an org migrates to Hyperforce.
The property of an operation that can be applied multiple times with the same result as applying it once. Integrations need idempotency because networks retry: a payment webhook or order message may arrive twice. Techniques include unique external IDs with upserts, deduplication keys and idempotency tokens on requests. Designing for it up front is far cheaper than reconciling duplicate records later.
An Apex method exposed to declarative tools with the @InvocableMethod annotation, letting Flow and agent platforms call custom logic with typed inputs and outputs. Invocable actions are the standard bridge between clicks and code: admins keep orchestration in Flow while engineers deliver hardened, bulkified building blocks. Design them as reusable, well-named operations rather than one-off endpoints for a single flow.
Integration Platform as a Service: cloud-hosted middleware for building, running and monitoring integrations — connectors, mappings, orchestration flows and error handling — without operating your own servers. Products in this category trade some control for speed and managed operations. Choosing among iPaaS, custom services and native platform eventing is a core decision in Salesforce integration architecture, driven by volume, latency and team skills.
A custom object with two master-detail relationships that models a many-to-many relationship between objects — for example, linking contacts to multiple programs through an enrollment object. The junction record can carry its own fields, such as role or date. Deleting either parent cascades to junction records, so consider the ownership, sharing and lifecycle implications the master-detail choice brings before committing.
The Salesforce object representing an unqualified prospect — a person or company that has shown interest but has not been vetted. On qualification, a lead converts into an account, contact and optionally an opportunity, entering the pipeline. Lead routing, deduplication and conversion mapping are common customization points, and the quality of this stage shapes everything downstream in quote-to-cash.
The modern Salesforce user interface, built on the Lightning component framework and replacing the legacy Classic UI. Pages are assembled from standard and custom components in Lightning App Builder, with record pages varying per app, profile or device, and dynamic forms controlling field visibility. Most new platform capabilities ship for Lightning Experience only, so remaining Classic usage is best treated as migration backlog.
Salesforce’s modern front-end framework built on web standards — custom elements, modules, decorators — for building UI components that run in Lightning pages, Experience Cloud sites and Flow screens. LWC replaced the heavier Aura framework and performs measurably better. Components call Apex or platform APIs for data. Reach for LWC when standard components and Flow screens cannot deliver the interaction the business needs.
A distribution container for Salesforce applications, primarily used on the AppExchange. Code inside is protected from subscriber view, upgrades are pushed by the vendor, and components live in the package’s own namespace. Versioning rules protect subscribers from breaking changes. ISVs and consultancies use managed packages to ship reusable products — accelerators, connectors, vertical apps — across many customer orgs at once.
The Salesforce API for deploying and retrieving org configuration — objects, fields, Apex classes, flows, layouts, permission sets — as XML or source-format files. Every deployment tool, from change sets to CI/CD pipelines, ultimately drives this API. Understanding what is and is not retrievable as metadata matters when planning environments, because non-deployable settings must be scripted or documented and applied manually.
Software that sits between systems to move and transform data: message brokers, ESBs, iPaaS platforms, custom integration services. Middleware isolates systems from each other’s data models and availability, centralizes mapping and error handling, and provides monitoring in one place. The alternative — direct point-to-point calls — is simpler at first but multiplies connections and hidden coupling as the system landscape grows.
A Salesforce-owned integration platform combining an ESB-style runtime, API management and prebuilt connectors. Teams build APIs and integration flows, deploy them to CloudHub or private runtimes, and govern them centrally. MuleSoft advocates API-led connectivity — layered system, process and experience APIs. It is a capable but licensing-heavy choice; smaller landscapes often start with lighter integration tooling and adopt it as complexity grows.
The architecture in which many customers share one platform infrastructure while their data and configuration remain isolated. Salesforce runs many orgs per instance, which is why governor limits exist and why upgrades arrive for everyone three times a year without customer-managed servers. Designing within multi-tenant constraints — shared resources, enforced limits — is the defining skill of Salesforce platform engineering.
A Salesforce feature that stores the endpoint URL and authentication details for an external service as configuration. Apex callouts and External Services reference the named credential instead of hard-coding URLs and secrets, and the platform handles token acquisition and refresh for OAuth flows. They separate credentials from code, simplify sandbox-to-production promotion and are the standard for outbound integration security.
Salesforce’s platform for nonprofit organizations, covering fundraising, program management, case management and grantmaking. The current generation of Nonprofit Cloud is built on the core platform with industry-standard objects, succeeding the earlier NPSP managed package — and moving between the two is a real migration project, not an upgrade. Discounted licensing through the Power of Us program changes the economics; verify current terms with Salesforce.
The open standard for delegated authorization used across Salesforce APIs. Instead of sharing passwords, an application obtains a scoped access token through a defined flow — authorization code for user-facing apps, JWT bearer for server-to-server jobs, client credentials for service integrations. Tokens expire and are refreshed. Choosing the right flow and the narrowest workable scopes per integration is basic security hygiene.
A Salesforce suite of declarative tools, originating from Vlocity, for building guided, industry-specific experiences: OmniScripts for step-by-step interactions, FlexCards for contextual data display, DataRaptors for data mapping and Integration Procedures for server-side orchestration. It is powerful inside the industry clouds but adds its own metadata layer and skills profile — weigh it against Flow and LWC before standardizing on it.
The Salesforce object representing a potential deal, tracked through pipeline stages from qualification to closed won or lost. Opportunities carry amount, close date, products and forecast category, feeding pipeline reports and revenue forecasts. Discipline in stage definitions and exit criteria determines whether the pipeline is a management tool or a fiction. Downstream, won opportunities trigger quoting, orders, contracts and billing.
The processes and systems that take a confirmed order through fulfillment: decomposition into deliverable items, orchestration across provisioning and shipping systems, status tracking, amendments and cancellations. Salesforce Order Management productizes this for commerce scenarios; complex B2B and telco cases often need custom orchestration. See order-to-cash on Salesforce for how orders connect quoting to billing.
A single tenant instance of Salesforce: one customer environment with its own data, metadata, users and licenses. Everything — objects, code, configuration — lives inside an org. Companies may run one org or several, split by region or business unit. Consolidation versus separation is a major architectural decision, balancing autonomy and risk isolation against data sharing, reporting and integration cost.
The baseline sharing setting per object that defines what users can see when no other rule grants access: Private, Public Read Only or Public Read/Write. OWD is the foundation of the Salesforce sharing model; role hierarchy, sharing rules and manual shares only open access upward from this baseline. Start restrictive — loosening access later is easy, while tightening it is a project.
A bundle of permissions — object and field access, Apex classes, system rights — assigned to users on top of their profile. Salesforce’s stated direction is minimal profiles, with permission sets and permission set groups carrying nearly all access, composed per persona. This makes access additive, auditable and easier to manage than proliferating profiles. Review assignments periodically, because they accumulate silently over time.
Salesforce’s publish-subscribe messaging on the event bus. Custom event types are defined like objects; publishers fire events from Apex, Flow or APIs, and subscribers — triggers, or external clients over CometD and the Pub/Sub API — react asynchronously. They decouple processes inside and beyond the org, with delivery allocations and replay windows to plan around. A common backbone for event-driven order orchestration.
The Salesforce structure that holds list prices: products link to price book entries per currency, and each opportunity or quote draws from one price book. Multiple price books support different segments, channels or regions. In newer pricing products the concept generalizes into catalog-driven price definitions, but the core idea holds — keep the product separate from its many prices.
The step-by-step derivation of a final price from a starting point: list price, then contracted discounts, promotions, manual adjustments and taxes, down to net price. Revenue Cloud models this explicitly as ordered pricing procedures, making every adjustment visible and auditable. A transparent waterfall shows exactly where margin leaks. See Revenue Cloud vs CPQ for how the two product generations price differently.
The Revenue Cloud module that acts as the single source of truth for sellable products: definitions, attributes, bundles and qualification rules, exposed through APIs to every selling channel. A shared catalog means CPQ, self-service commerce and AI agents all sell from the same definitions. Catalog modeling quality — clean attributes, disciplined bundle structure — determines how maintainable the whole revenue stack stays.
The Salesforce construct defining a user’s baseline access: login hours, IP ranges, default record types and — historically — object, field and system permissions. Current best practice slims profiles down to defaults and moves permissions into permission sets. Every user has exactly one profile, so treat it as an identity baseline rather than the mechanism for day-to-day access management.
A Salesforce tool for creating reusable, grounded prompt templates for generative AI features. Templates merge CRM record data, related lists and Flow-supplied context into the prompt, execute through the Einstein Trust Layer, and return outputs into fields, Flows or agent actions. It turns prompt engineering into versioned, testable configuration rather than free text pasted into a chat window by each user.
An asynchronous Apex pattern for background jobs that need more than a future method offers: job chaining, non-primitive parameters and a job ID to monitor. Enqueued jobs run when platform resources allow, with the higher limits of asynchronous execution. Chain depth and concurrency have platform caps, so long pipelines need deliberate design. It is the workhorse for callouts and staged processing after user actions.
A record capturing a proposed deal at a point in time: products, quantities, prices, discounts and terms, usually rendered as a document for the customer. Multiple quotes can exist per opportunity, with one syncing back as the source of truth. In CPQ systems the quote is where configuration and pricing rules converge, and the approved quote feeds orders and contracts downstream.
The end-to-end business process from configuring a quote through contracting, ordering, fulfillment, invoicing, payment and revenue recognition. Quote-to-cash spans sales, operations and finance systems, which is why it usually breaks at the seams between them. Treating it as one architected process — shared data model, explicit handoffs — rather than a chain of isolated tools is the core argument of quote-to-cash on Salesforce.
A Salesforce mechanism for offering different picklist values, page layouts and business processes on the same object — separating, for example, new-business and renewal opportunities. Record types shape user experience and automation branching, but each one multiplies configuration surface and testing effort. Add them for genuinely different processes, not cosmetic variation, and prune unused ones during periodic cleanup.
Salesforce’s general-purpose HTTP API for reading and writing records, running queries and calling platform features using JSON. It suits interactive, record-level integrations; high-volume loads belong on the Bulk API and multi-step operations on the Composite API. Every call consumes the org’s rolling 24-hour API allocation, so integration designs should budget calls, batch sensibly and cache reference data.
A technique in which a language model’s prompt is enriched with relevant documents or data retrieved at request time, so answers are grounded in current, private information rather than only training data. In a Salesforce context, agent and prompt features retrieve CRM records and indexed knowledge to ground their outputs. RAG reduces hallucination, but only as far as retrieval quality and source hygiene allow.
Salesforce’s current-generation revenue platform, built natively on the core platform, covering product catalog, pricing, configuration, quoting, orders, contracts and billing under the Revenue Lifecycle Management umbrella. Revenue Cloud succeeds the managed-package CPQ and Billing products with an API-first architecture and a shared catalog. Existing CPQ customers face a genuine migration, not an upgrade — see this CPQ to Revenue Cloud migration guide.
Salesforce’s name for managing revenue processes end to end on Revenue Cloud: catalog and pricing definition, quoting, contracting, order capture, amendments, renewals and billing feeding revenue recognition. RLM emphasizes one product catalog and one pricing engine serving every channel — sales-led, self-service or agent-led. This Revenue Lifecycle Management overview walks through how the pieces fit together.
Salesforce’s core selling product: leads, accounts, contacts, opportunities, forecasting, activity tracking and sales analytics. It is where most Salesforce implementations begin. Editions differ meaningfully in automation, API access and sandbox allowances, so edition choice is an architectural constraint rather than a licensing detail. Sales Cloud data becomes the foundation that quoting, order and billing layers later build on.
The developer-experience toolchain for Salesforce: the sf command-line interface, source-format metadata, scratch orgs and packaging. DX moved the source of truth from the org into version control, enabling modern workflows — feature branches, automated tests, continuous integration. Adopting it is as much a process change as a tooling change, and most teams migrate incrementally from org-based development rather than all at once.
A copy of a production Salesforce org used for development, testing and training. Types differ by refresh frequency and data: Developer and Developer Pro copy configuration only, Partial Copy adds a data sample, and Full Copy replicates production data. A deliberate sandbox strategy — which environment serves which purpose, and how often each refreshes — underpins any serious release process.
A short-lived, source-driven Salesforce environment created from a definition file and destroyed after use, typically within days. Scratch orgs give every developer or CI job a clean, reproducible org whose shape comes from version control rather than accumulated history. They complement sandboxes rather than replace them: scratch orgs for build and automated testing, sandboxes for integration and user acceptance.
Salesforce’s customer service product: cases, omni-channel routing across email, chat, voice and messaging, knowledge management, entitlements and agent consoles. It aims to resolve issues faster by putting customer context and guided processes in front of service agents — increasingly with AI assistance drafting replies and summarizing conversations. Service metrics live or die by clean case data and sound routing design.
The combined set of mechanisms controlling record visibility in Salesforce: organization-wide defaults, role hierarchy, sharing rules, teams, manual sharing and Apex-managed sharing. Together with object and field permissions, it answers who sees what and why. Complex sharing is a frequent performance and audit pain point, and a structured architecture review often starts by mapping it end to end.
Salesforce’s add-on security suite: Platform Encryption for encrypting field data at rest with customer-controlled keys, Event Monitoring for detailed user-activity logs, and Field Audit Trail for extended history retention. Regulated industries buy Shield for compliance requirements that baseline platform security does not cover. It affects architecture — encrypted fields constrain filtering, sorting and some features — so plan before enabling it.
Salesforce’s original XML-based web services API, still supported for record operations and used by older middleware through the enterprise and partner WSDLs. New integrations generally prefer the REST, Bulk or Pub/Sub APIs, but SOAP remains relevant where legacy systems already speak it or where strongly typed WSDL contracts are required by enterprise tooling. Functionally it overlaps REST for CRUD and query.
The generic term, and the Apex base type, for any Salesforce object record, standard or custom. Apex can work with concrete types like Account or generically with SObject, enabling dynamic, reusable logic driven by describe metadata. Dynamic SObject handling powers frameworks and generic utilities, at the cost of compile-time safety — a classic flexibility-versus-strictness trade-off worth making consciously.
Salesforce Object Query Language: the SQL-like language for querying records, using relationship traversal instead of joins, plus aggregate functions and semi-joins. SOQL runs against org data under enforced limits on returned rows and query counts per transaction. Query selectivity — filtering on indexed fields — is what separates queries that scale from queries that time out as data volumes grow.
Salesforce Object Search Language: full-text search across multiple objects in a single query, returning matching records grouped by object type. Where SOQL asks precise questions of known objects, SOSL finds text across name, phone, email and custom fields simultaneously. Use it for user-facing search boxes and cross-object lookup; use SOQL when you know exactly what you are filtering on.
The handling of recurring revenue relationships across their lifecycle: initial sale, mid-term amendments, upgrades, co-terming, renewals and cancellation, with correct proration at every step. Salesforce addresses it through Revenue Cloud’s quoting and billing capabilities and API-first self-service products. Amendment and proration logic is where subscription implementations earn their keep — model it early against real commercial scenarios.
The accumulated cost of past shortcuts and outdated decisions in a system: brittle automation, duplicated logic, dead fields, undocumented integrations, skipped tests. Debt is not inherently bad — it can be a rational trade — but unmanaged debt slows every subsequent change and raises incident risk. Structured remediation works; this technical debt rescue guide lays out a sequencing approach.
The percentage of Apex code lines executed by unit tests. Salesforce requires 75% org-wide coverage to deploy Apex to production, with every trigger exercised. Coverage is a floor, not a goal: tests should assert behavior, cover bulk and negative paths, and run against representative data. Assertion-free tests can pass deployment while proving nothing — code review exists to catch exactly that.
A Salesforce DX packaging type for a customer’s own code and configuration, grouping metadata into versioned, installable units without the vendor protections of managed packages. Unlocked packages bring modular architecture to internal development: explicit dependencies, repeatable installs, cleaner orgs. Most of the benefit comes from the discipline of deciding package boundaries — by business domain, not by team convenience.
A pricing model in which charges depend on consumption — API calls, seats used, transactions processed — rather than flat recurring fees. Implementing it requires reliable usage capture, aggregation, rating against price tiers and invoicing, often with commitments and overage rules layered on top. Revenue platforms support usage products natively to varying degrees; the hard engineering is usually the trustworthy usage data pipeline.
A declarative Salesforce rule that blocks saving a record when a formula condition evaluates true, returning an error message to the user or the API caller. Validation rules protect data quality at the platform boundary, firing regardless of entry channel. Keep them consistent with integration behavior — a rule that surprises middleware causes silent synchronization failures — and document any exemption logic explicitly.
Salesforce’s legacy page framework using server-rendered markup backed by Apex controllers. It predates Lightning and survives in many orgs for PDF generation, email templates and older customizations. New UI work belongs in Lightning Web Components; Visualforce persists mainly where PDF rendering is required or migration has not been prioritized. Treat a significant Visualforce estate as measurable, addressable technical debt.
An HTTP callback in which one system notifies another by POSTing to a registered URL when an event occurs — a payment succeeded, a document was signed. Salesforce consumes webhooks through public endpoints such as sites or middleware, and emits similar patterns via outbound messages and event relays. Verify signatures, respond fast, process asynchronously and design for duplicate delivery. Payment integrations lean heavily on webhooks.
A built-in Salesforce feature that generates an HTML form which creates lead records directly from a website. It is quick to deploy but limited: basic spam protection, limited validation and no enrichment. Higher-volume or higher-stakes capture usually moves to API-based submission with server-side validation, enrichment and deduplication applied before records ever reach the sales team’s queue.
Go deeper than definitions — engineering guides from the same team.
Revenue Cloud vs CPQ: what actually changed→ Salesforce integration patterns that hold up in production→ Apex best practices for code that survives scale→ Quote-to-cash on Salesforce, end to end→ When to write Apex — and when to walk away→Talk to a senior Salesforce engineering team about what these terms mean for your architecture.