Insights
Ideas for systems that work in the real world.
Practical perspectives on Salesforce, integration, enterprise architecture and the disciplined use of AI.
Featured perspective
13 October 2026 · Apex Testing & Integration Reliability · 8 min read
A mocked callout proves your Apex—not your integration
HttpCalloutMock is excellent for fast, deterministic unit tests. It cannot prove that the real endpoint, contract, identity and recovery behaviour will work together in production.
Read the articleLatest thinking
More from JSBC Labs
Your Salesforce API limit is an architecture budget—not a project quota
API capacity is shared across an org, so every integration design changes the operating margin available to every other consumer. Govern demand before the limit becomes an incident.
Your Salesforce backlog is not an architecture roadmap
A ranked list of requests explains what teams may build next. An architecture roadmap explains which capabilities, dependencies and risks must change so the platform can keep delivering.
Lightning Message Service is not application state management
Lightning Message Service connects components across DOM boundaries. Used as invisible global state, it creates timing dependencies, stale views and contracts nobody owns.
Duplicate management is a decision system—not a cleanup switch
Matching records is only the first decision. Reliable duplicate management also governs false positives, channel behaviour, ownership, merging and measurable data-quality outcomes.
A subflow is an API contract—not a diagram shortcut
Reusable Flow logic becomes a dependency shared by many automations. Govern inputs, outputs, failure semantics, versions and tests with the same discipline as an API.
Agentforce grounding is a data pipeline—not a prompt setting
Connecting an agent to trusted content does not guarantee a trusted answer. Freshness, structure, retrieval, permissions and evaluation determine what reaches the model.
Platform Cache is a performance layer—not a source of truth
A cache should make correct behaviour faster, not become the only place that behaviour exists. Design misses, invalidation and recovery before celebrating hit rates.
Custom Metadata is configuration—not a database shortcut
Deployable configuration can make Salesforce applications adaptable. Used as an ungoverned table for mutable state, it creates hidden releases, weak ownership and brittle runtime behaviour.
An Experience Cloud guest user is an internet-facing identity—not a free licence
Unauthenticated does not mean unprivileged. Every public page, form, Apex method and shared record expands an internet-facing identity that must be designed, tested and monitored.
An Apex trigger framework is not your domain architecture
A framework can standardise dispatch, ordering and recursion control. It cannot decide who owns a business rule, where a transaction should end or what failure means.
A Salesforce backup is not a recovery plan
A backup proves that copies exist. Recovery proves that data, metadata, files, identities and integrations can be restored in the right order within a business-approved time.
A second Salesforce org is an operating-model decision—not a partitioning shortcut
An org boundary separates data, automation, identity, releases and accountability. Create one only when the business can own the integration and governance it introduces.
A Data Cloud segment is production logic—not a marketing list
Segment membership determines who receives an offer, intervention or exclusion. Govern the grain, freshness, consent, activation contract and change lifecycle like production decision logic.
Your sharing model is also a performance model
Record access is enforced through ownership, hierarchies, groups and shares that must be maintained as data and organisations change. Design security and scale together.
Field History Tracking is evidence—not an audit strategy
Tracked field changes answer one narrow audit question. A defensible Salesforce audit model also needs scope, retention, configuration evidence, user activity, business context and tested retrieval.
An integration user is a machine identity—not a shared administrator
A dedicated username is only the start. Govern every Salesforce integration identity by workload, least privilege, authentication, observability, rotation and an executable exit plan.
A Salesforce data migration is a product release—not a loading exercise
A migration changes operational truth, identity and business behaviour. Govern mapping, cutover, reconciliation and recovery as a release—not a file upload.
A Flow fault connector is not an error-handling strategy
A fault path changes where a Flow goes after an error. Reliable automation still needs explicit decisions about atomicity, diagnosis, recovery, ownership and testing.
A validation rule is a public contract—not a form message
Validation rules govern every save path, not only a record page. Design their semantics, exceptions, errors and rollout as shared platform contracts.
Formula fields are not free computation
Formula fields remove storage and update logic, but they move calculation into every read path. Treat frequently filtered, sorted and integrated values as an architectural decision.
A Salesforce sandbox is not a production rehearsal
Production confidence comes from layered evidence across configuration, data, identity, integrations, load and recovery—not from calling one sandbox production-like.
Your Salesforce object model is not an integration contract
Standard REST resources expose records efficiently, but enterprise consumers need a deliberate contract for business intent, identity, security, errors and change.
A reusable LWC is a product—not a code snippet
Reuse creates consumers, and consumers create contracts. Govern public properties, events, configuration, accessibility and change as a product with an owner.
Queueable Apex is not a performance button
Moving work to Queueable Apex changes its transaction, timing and failure contract. Design intent, idempotency, observability and backpressure before calling System.enqueueJob.
A unified profile is not a golden record
Data 360 can link customer identities and reconcile attributes, but authority still belongs to governed source systems, explicit stewardship and purpose-specific activation rules.
A permission set called ‘Sales Manager’ is already technical debt
Job titles change faster than capabilities. Model Salesforce permission sets around reusable tasks, compose personas with groups and govern assignment as a lifecycle—not a naming exercise.
An Agentforce pass rate is meaningless without a risk model
One average score can hide the only failures that matter. Agent testing should weight business harm, verify actions and measure complete conversations—not reward plausible wording.
UNABLE_TO_LOCK_ROW is an architecture warning—not a retry instruction
Retries can absorb brief contention, but recurring Salesforce row-lock failures usually reveal a hot parent, an overlong transaction or competing workload design.
A Salesforce seasonal release is an architecture event—not admin homework
Winter ’27 is already moving through production. Release readiness should test the contracts your architecture depends on, not produce a long list of features nobody owns.
Your Salesforce CoE should reduce waiting—not create it
Good governance gives teams faster access to safe decisions. If every change waits for one committee, the operating model has centralised delay instead of expertise.
A successful deployment is not a Salesforce release
Metadata arriving in production proves that a transport step worked. A release succeeds only when dependencies, activation, adoption, signals and recovery are controlled end to end.
Bulkified Apex can still be the wrong architecture
Moving SOQL and DML outside loops prevents obvious failures. Production Apex also needs bounded work, explicit contracts, coordinated writes and a deliberate transaction model.
An Agentforce action is a production API—not a prompt trick
Once an agent can change records or call another system, action design—not conversational polish—determines whether the solution is safe to operate.
Not every customer fact belongs in Salesforce
A useful customer view is not a copy of every source system. It is a governed decision about which data to store, summarise, virtualise or archive.
Publishing a Platform Event does not complete the integration
Reliable event-driven integration begins after dispatch: with transaction semantics, replay, idempotency, observable outcomes and reconciliation.
A slow Lightning page is usually a data-design problem
Before optimising JavaScript, inspect how many data contracts the page creates, how much each one retrieves and how consistently its caches are refreshed.
Salesforce security starts with data classification—not permission sets
Access controls become guesswork when an organisation has not defined which data is sensitive, why it is retained and who is accountable for it.
Code coverage is not a Salesforce testing strategy
The platform's 75% deployment threshold measures which lines ran. It does not prove that your business processes, permissions or integrations work.
Flow versus Apex is the wrong first question
Start with automation density, transaction risk and dependency sprawl. The tool choice becomes clearer once the architecture is visible.
AI does not fix a broken process
Automation can make a business faster. It can also make a bad process fail at greater speed. The difference is the work done before the technology arrives.
The integration is the product
Customers experience one business, not a collection of platforms. Your integration architecture decides whether that experience feels connected or fragmented.
Salesforce should follow the business—not the demo
A polished demonstration can sell a feature. A successful platform must support the real operating model, including its difficult edges and exceptions.
Salesforce daily archive
Two years.
One note per day.
Explore 730 retrospective notes covering Salesforce architecture, development, seasonal releases and platform operations.
Browse the complete archive