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
3 November 2026 · Lightning Experience Performance & Page Architecture · 8 min read
A Lightning record page is a dependency graph—not a layout
Every visible field, related list and custom component can add data, metadata, rendering and automation work. Design record pages as measured task-specific dependency graphs, not visual containers.
Read the articleLatest thinking
More from JSBC Labs
Field History Tracking is not an audit architecture
A related list of changed values can answer useful questions, but defensible audit evidence requires deliberate scope, retention, access, review and correlation across several Salesforce evidence sources.
A Named Credential is a trust boundary—not a URL shortcut
Removing a URL and secret from Apex is only the first step. A sound Named Credential design makes endpoint, identity, authorization, lifecycle and failure ownership explicit.
A Salesforce data migration is a product release—not a file upload
The CSV is only a transport format. A reliable Salesforce migration defines authority and identity, rehearses production-scale behaviour, reconciles business outcomes and operates cutover with evidence and recovery options.
An LWC is not a transaction coordinator
A polished component can sequence several saves, but the browser cannot make them atomic. Put business consistency on the server, make submissions idempotent and reconcile every client cache deliberately.
A Salesforce architecture review should create decisions—not delay delivery
Architecture review earns its place when it resolves material trade-offs early and records accountable decisions. Risk-tier the work, automate routine standards and make every exception explicit.
A Flow scheduled path is not a job queue
Scheduled paths are excellent for record-specific future actions, but they are not a durable queue with delivery guarantees, retries and workload control. Design them around record lifecycle and operational evidence.
Data Cloud Zero Copy is not zero governance
Federation can remove replication pipelines, but it does not remove ownership, semantics, access control, freshness, cost or recovery obligations. Govern the shared data product end to end.
Transaction Security is a circuit breaker—not a permission model
Real-time policies can block, challenge or notify on risky behaviour, but they do not replace least privilege. Design narrow controls with tested failure modes, evidence and accountable exceptions.
A custom report type is a semantic contract—not a report shortcut
A report type decides which records exist, how relationships behave and which fields users interpret. Govern its grain, semantics, security and lifecycle like a shared data product.
Change Data Capture is not a business event contract
CDC is excellent at reporting record mutations, but a changed row does not explain business intent. Build consumers around ordering, replay, schema evolution, reconciliation and explicit domain meaning.
Agentforce escalation is an operating model—not a fallback phrase
Human handoff is a production workflow, not a polite sentence at the end of a failed conversation. Design explicit triggers, context transfer, capacity-aware routing and closed-loop ownership.
Deleting Salesforce metadata is a migration—not a cleanup task
A destructive deployment can remove code, configuration, access and data-bearing structures in one change. Retire metadata through dependency analysis, staged migration and verified recovery—not repository tidying.
The smallest Invocable Apex method can create the largest coupling
An @InvocableMethod is an enterprise interface, not a private helper. Design its schema, bulk behaviour, security, failure semantics and lifecycle before multiple automations depend on it.
A test data factory is a domain model—not a convenience class
Good test data describes valid business states, not merely insertable records. Treat factories as governed domain infrastructure so tests stay readable, isolated and honest as the org evolves.
An index cannot rescue an unbounded Salesforce data model
Indexes accelerate selective access. They cannot compensate for limitless active data, weak segmentation, broad searches or a workload whose definition of ‘current’ grows forever.
Your Apex API version is now a security control
API 67 changed Apex security defaults. Treat version upgrades as security migrations: make access intent explicit, test real personas and review every privileged exception.
Debug logs are not a Salesforce observability strategy
Debug logs help explain a transaction after someone knows where to look. Reliable Salesforce operations need correlated telemetry, meaningful service measures, deliberate alerting and owned response.
Activating a Flow version is not release management
Flow activation changes which version starts next. A reliable release also controls dependencies, compatibility, testing, in-flight work, rollback and production evidence.
Using SLDS does not make your LWC accessible
SLDS can supply a familiar visual language. Accessibility still depends on semantics, focus, state communication, component boundaries and evidence from real interaction testing.
A Salesforce record type is not a business process
Record types can shape layouts, picklists and supported process metadata. Used as workflow states, security boundaries or organisational labels, they create expensive coupling across the platform.
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.
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