Field Notes

After fifteen years on the platform, the pattern is clear: a small set of unglamorous features carries almost all the value. Here's the 20% I protect first.

The economic shifts AI is bringing to Salesforce consulting — what's getting cheaper, what's getting more valuable, and what the agency model looks like now.

I spent a year prepping for the Salesforce CTA review board, then withdrew. The honest reasoning: the cost, the breadth trap, and what I chose to do instead.

An honest read on Australia's Salesforce consulting market in 2026 — the two-tier split, real day rates, the offshore ceiling, and where boutiques win.

The actual workflow I run for AI-assisted Apex development — what AI handles well, what it gets wrong, and the prompts that survive code review.

Technical debt on Salesforce has a real interest rate, and it compounds where you don't look. How I measure it, cost it, and decide what's worth paying down.

I sell Salesforce architecture for a living, and sometimes the advice is to walk away from the platform. Here's how I decide when Salesforce is the wrong tool.

Fifteen years of Salesforce, ten orgs, three major platforms shifts, and a long list of mistakes. The lessons I'd pass back to the version of me who started in 2010.

How I actually use AI across a Salesforce data migration — profiling, field mapping, and the transform Apex — plus the near-miss that set my one hard rule.

AppExchange security review is a grind of scanner findings and questionnaires. Here's how I use AI to triage the report, fix CRUD/FLS at scale, and pass sooner.

Cloud AI is off the table at regulated Salesforce orgs. Here is how I run local models with Ollama for Apex and SOQL, the hardware, and the honest limits.

AI writes cleaner SOQL than I do at 5pm — right relationships, right field names. But it can't see your data volumes. Here's where it helps and hurts.

AI can hit Apex code coverage in seconds, but coverage was never the point. Here is what AI test generation gets right, where it fails, and how I use it.

The SOQL antipatterns I keep finding in code review, the patterns that replace them, and the trade-offs nobody explains — from years of production Salesforce.

How I run AI code review on Apex pull requests: the pipeline, the prompt rubric that cuts the noise, and the bulkification bugs two tired humans skim past.

Choosing between Queueable, Batch Apex, and Future methods is the asynchronous decision most Salesforce devs get wrong. Here's the framework I use, and the cases where the obvious choice is wrong.

How my Salesforce dev loop actually runs now that agents write the boilerplate — the context files, specs, review gates, and pipeline that hold it together.

How I run Cursor and Claude Code as a working Salesforce IDE: the Apex language server setup, the context files, the deploy loop, and the parts that break.

What it actually takes to ship a Second-Generation managed package on Salesforce — the namespace, the version pipeline, the gotchas, and the trade-offs.

Bulk API failures are rarely about the daily record cap. How I handle row locks, batch sizing, and automation during large loads, with real production code.

What actually goes into a clean Salesforce data migration — from field mapping through cutover — and the gotchas that turn one-week migrations into one-month projects.

The REST integration patterns I actually use in production Salesforce orgs: named credentials, async callouts, idempotency, and when to skip REST entirely.

Salesforce duplicate management fails when it blocks the wrong people. Here's how I tune matching rules and duplicate rules so they help users, not nag.

The Flow patterns that quietly destroy performance — and the fixes that have worked for me on government and financial services orgs.

How I run Salesforce delta deployments with sfdx-git-delta — the pipeline wiring, test-level choices, destructive-change traps, and where delta lies to you.

Most Apex tests pass coverage and catch nothing. The patterns that actually catch bugs — test data factories, behaviour assertions, governor limit checks, and the bulk cases everyone skips.

Dynamic SOQL fails more AppExchange security reviews than almost anything. Here's how I build queries that can't be injected — binds, allowlists, user mode.

The CRUD and FLS enforcement patterns that actually pass AppExchange security review — and the antipatterns the scanner keeps flagging.

Try-catch is where Apex error handling starts, not where it ends. Custom exceptions, persisted logs, partial-success DML, and errors that survive a rollback.

Sharing rules, manual sharing, or Apex managed sharing? After years spent untangling Salesforce security models, here's how I decide which one to reach for.

Most Salesforce orgs start with a handful of triggers and end up with a mess. Here's the framework I've used across government, financial services, and ISV orgs — and why the boring parts matter most.

Assigning permission sets one by one turns into sprawl nobody can audit. Here's how I use permission set groups and muting sets to make access legible again.

Record-triggered flows or Apex? I've built both in production for years. Here's the exact framework I use to decide, and where each one quietly falls apart.

Most admins use custom metadata for one lookup table and stop. Here's how I use it to kill hardcoded config, dodge governor limits, and keep rules in source.

Salesforce has been nudging us toward permission sets for years. Here's how I actually did the migration on a large government org — the strategy, the gotchas, and what I'd do differently.

Platform Events and Change Data Capture look similar but solve different problems. Here's how I decide between them on real Salesforce integration work.

The domain layer patterns I actually use in production Apex — how fflib domain classes plug into triggers, where validation belongs, and when it's overkill.

Everyone talks about CI/CD for Salesforce, but most guides skip the hard parts. Here's what I've built with GitHub Actions, scratch orgs, and delta deployments — and the compromises you'll have to make.