Eleven years in Salesforce, the last two spent building the AI the platform did not ship with: an agentic control plane over the org, autonomous Apex test generation inside the Einstein trust boundary, and an agent driven delivery pipeline that carries a ticket from branch to deployment to written documentation.

Five scored lenses over one Salesforce estate, covering spend, health, adoption, commitment and data. Each finding is priced in dollars where a defensible rate exists, and the lot is ranked as a single backlog under one composite score. The question it answers is not "is the org healthy" but "what should we do next week, and what is it worth".

• The composite is capped at 15 points above the weakest lens. A majority of healthy lenses is not allowed to mask a critical one, which is exactly what an average would do.
• Roughly 90 percent of it has no model in it at all. Deliberate: a number that needs a model to produce is a number nobody can audit.
• Cannot write to production by construction. Not configured not to. The class that talks to production issues GET and contains no method capable of sending a record.
• The agent proposes, a human disposes. The analyst runs in GitHub Actions, writes a fix and opens a draft pull request. It never auto merges. Change plans go propose, approve, dispatch, verify, and the executor takes an id, not a payload, so the set of things it can do is exactly the set somebody read and approved.
• Provenance is read from the data, not the settings. A source badge rendered from configuration once displayed a stale sandbox snapshot under a production label. It now reads the org stamped on the rows themselves.

Salesforce native autonomous Apex test generation, coverage measurement and failing test repair, built against an org of over 1,000 Apex classes. Self initiated after org wide test coverage kept surfacing as an engineering gap.

• Runs on the in platform Models API, behind the Einstein Trust Layer. No external callout, no API keys, and no code leaves the Salesforce trust boundary. The model name is configuration, so it repoints without a deploy.
• A Queueable state machine. Generate, compile, run, measure and repair are independent transactions, which is what lets the loop run at scale inside governor limits.
• Salesforce's own coverage table was lying. The aggregate reported zero percent for classes that were demonstrably covered, so coverage measurement was rebuilt from first principles rather than trusted.
• Every prompt carries hard rules that are scar tissue from observed failures. The load bearing one: every method must contain a meaningful assertion. Without it a model writes a method that calls everything, asserts nothing, and reports full coverage.
• Safety controls in the dashboard rather than in a runbook: a kill switch, a no progress guard and a regression guard, on an LWC that shows what the loop is doing.
• Proven end to end. Piloted against a 454 class and trigger inventory, it took a class from 0 to over 73 percent coverage with zero human written test code.

Sole architect and developer of a 100 percent Salesforce native CI/CD application, plus the Claude skills that drive it. The full release lifecycle runs inside Salesforce: a Release Manager LWC walks each release through its steps while Apex services call GitHub and Jira Cloud through Named and External Credentials, dispatch GitHub Actions to run the metadata deployment, and poll for the result. No scripts, no leaving the platform, and no secrets in code.

• Three deployment flows on one engine. Staging, production and dev backup, each with server computed step gating so the UI reflects real release state rather than what the browser last believed.
• A component level copy pattern for production. Merging whole branch histories diffed thousands of files. Instead each ticket's package.xml is resolved to specific file paths and only those components are copied into a working branch, so the pull request contains the actual change set and can be reviewed.
• Branch matching that survives a 2,600+ branch repository. The fast path uses GitHub's matching refs API with case variant prefixes; the fallback is a normalised paginated scan that ignores case, separators, prefixes and suffixes, so arbitrary names still resolve.
• Undocumented API behaviour. Jira Cloud's pagination deviates from Atlassian's own documentation, so the client had to be written against observed behaviour rather than the spec. Metadata dependency resolution covers the child types that catch people out: validation rules, workflow rules, field updates, record types and list views.
• Contents API concurrency. Every file write is its own commit and moves the branch head, so the SHA read for one file is stale for the next and GitHub returns 409. Solved with a refetch and retry loop, per callout timeouts, smaller batches to stay inside Apex callout limits, and Queueable chaining.
• Merge state correctness. A true conflict and "already merged through another pull request" look alike and both stall a release. Reading changed files, commits and merged status off the pull request separated them, which stopped components being silently dropped from deploy previews.
• Governor and runtime hardening. Regex string operations failed with "Regex too complicated" on large base64 payloads and were replaced with literal operations; GitHub Actions is pinned to Node 18 and a fixed Salesforce CLI version after Node 20 crashed it.
• Configuration driven throughout. Branch names, ready statuses, endpoints and workflow routing live in Custom Metadata, nothing is hardcoded, and the app is built to be packaged and reused.

The applied end: getting generative features in front of support agents, then measuring whether they were actually worth the credits.

• Instrumented the Support AI platform. Prompt metric tracking and agent feedback across Suggested Reply, Similar Cases and Internal Assistance, which previously had no visibility into whether agents found the output useful.
• Agentforce case deflection proof of concept, a screen flow calling Prompt Builder to draft grounded case comments from case context. Demoed to Directors and the CIO, and presented to a visiting US engineering team at a cross team showcase.
• An Agentforce token consumption dashboard giving leadership usage per action and projected monthly cost. It informed production cost governance, and it is the other half of the Flex Credit analysis: surface the cost, then explain the overage.
• A custom similar case matching engine, combining SOSL candidate search, SOQL filtering and weighted multi field scoring, surfacing resolution patterns from historical cases rather than just near duplicates.
• Built on Flow orchestration, Prompt Builder templates and Invocable Apex for context assembly, with a usage and feedback layer measuring whether reps actually adopted the suggestions.
• Agentforce Flex Credit overage root cause analysis and control playbook, written as an internal leadership briefing: what was over, where the credits went, when, why, and the controls to stop it recurring.
• Salesforce MCP adoption with propose, approve, dispatch and verify gating, and independent checks that prove the target org is a sandbox before any write leaves.