Today11 stories · 1 brief

The Daily Org

Spring '27Sandboxes 6 Feb 2027

Curated by Abhinav (opens in a new tab)

Vol. I · No. 26The independent daily for Salesforce admins, developers and architects11 stories · 1 brief

Must-readDevOps

A raw List in an @InvocableMethod stops Apex completion across the whole file (opens in a new tab)

You will learn how a raw List parameter in an @InvocableMethod crashes the Apex language server and disables member completion in the file, which signature shapes trigger it, and how the author's VS Code extension detects and fixes them.

Raw List in @InvocableMethod

  • Server logs IllegalArgumentException
  • Completion lost across the whole file
  • Shape not checked against element type

Raw List in plain method

  • Only a syntax error is reported
  • Completion keeps working
  • Harmless, so not flagged
Raw List parameters break completion in invocable methods but not in ordinary ones

The author wrote an @InvocableMethod with a raw List parameter and found that member completion stopped working throughout the class, while the Problems panel showed only a generic syntax error. The cause is an exception inside jorje, the Apex language server in the Salesforce Extension Pack. For invocable, static @AuraEnabled, @Http and global methods, the server unwraps the element types of collection parameters and expects exactly one type argument, so a raw List produces an empty list and the check fails.

To separate harmful shapes from harmless ones, the author ran the language server headless against 274 signatures and recorded whether it logged an exception and whether completion came back empty. A raw List in an invocable method crashed the file, as did List, unfinished forms and wrong argument counts. A raw List in an ordinary method was only a syntax error with completion intact, and Set and Map in invocable methods were clean. A raw collection as a return type makes the parser drop the method, which limits the damage to that method.

The author’s extension, Virga, flags only the shapes that broke, using two diagnostic codes, and offers quick fixes that insert a type such as List chosen from the file. After applying the fixes, the server stopped throwing in all 184 breaking cases and completion returned in 180 of 181 where it had failed.

Read the original at dev.to (opens in a new tab)

Worth reading?

Must-readDevOps

Sharding Apex tests across CI jobs with renmy runtime (opens in a new tab)

You will learn how to split one Apex test suite into parallel slices across CI runners, how classes are balanced by recorded duration, and when sharding is not worth the overhead.

Why read this

The article gives a working GitHub Actions matrix and explains how to merge the JUnit results.

  1. Balance classes by recorded duration
  2. Run each slice on its own CI job
  3. Merge the shard JUnit XML results
Sharding assigns each test class to exactly one runner, then the results are merged

The article explains how to split one Apex test suite into parallel slices across CI runners using renmy runtime, a local Salesforce Apex runtime from Renmy UG that runs tests on the CI machine against an embedded PostgreSQL instead of in a Scratch Org or sandbox. The author argues that sharding was impossible in an org-based workflow, because every extra runner would need its own org, deploy and place in the org’s test queue. With a local runtime, the command renmy test –shard N/M runs one slice of the suite, and the wall-clock time falls to roughly the slowest shard plus setup, though total compute rises slightly. The runtime was previously called Nimbus, and the author notes that this is the same tool under a new name.

Sharding works at the level of whole test classes, so each class’s @testSetup runs once and its records remain consistent with an unsharded run. Classes are balanced using durations recorded in .nimbus/test-durations.json, and projects without that history fall back to an even split by class name. Because each shard computes the partition independently, every job must see the same durations file, which the author recommends committing or restoring from a cache. The article supplies a GitHub Actions matrix with fail-fast disabled, a per-shard JUnit file, and an always-run publishing step. It also shows how to merge results either through the shard attribute that the JUnit XML carries or by uploading artifacts and publishing them from a job that runs after the matrix.

The piece also covers coverage and caching. A shard measures coverage only for the tests it runs, so whole-suite coverage needs a single process, and the article points to renmy deploy –min-coverage and renmy coverage diff for gating. Shards can share a cache of parsed ASTs and the binary to reduce cold-start time.

Finally, the author warns that sharding is not worth its overhead for suites that finish within about a minute, since each shard repeats checkout, installation and database startup. Alternatives suggested first are parallel workers within one job, caching, and an external PostgreSQL service container. Sharding is recommended when the test step alone runs for several minutes. A slow class sets a floor on its shard’s time, and order-dependent tests can surface when classes move between shards. Running on a CI runner belongs to the Team tier, which is free during the public beta, and JUnit and Cobertura output are Pro features.

Read the original at dev.to (opens in a new tab)

Worth reading?

RecommendedArchitecture

Trigger Lib: a role-based Apex trigger framework built around governor limits (opens in a new tab)

You will learn how Trigger Lib splits trigger logic into populators, validators, writers and dispatchers, how orchestrators and Custom Metadata Types register handlers, and how its add-on interfaces bulkify queries and batch DML.

Trigger Lib handler roles

  • Populator
  • Validator
  • Writer
  • Dispatcher
Trigger Lib has four handler roles, each with one job in a trigger context

The article introduces Trigger Lib, an open-source Apex trigger framework from the Apex Fluently collection, written by an author who argues that Flows are impractical and that Apex triggers are the best automation option, provided they are organized well. The author’s main complaint is that existing trigger frameworks rarely help teams manage governor limits, which become a serious risk when AI-generated code and other automations share a transaction. Trigger Lib is deliberately not metadata-driven. It can be started with an orchestrator class that lists handlers, or with runFromMetadata() for handlers registered in Custom Metadata Types, and Custom Metadata is then used only to switch handlers off.

Handlers are split into four roles: Populators set field values in before insert and update, Validators reject invalid records in before contexts, Writers queue DML on a shared Unit of Work in after contexts and before delete, and Dispatchers start Queueable jobs or publish events in after contexts. Each role has a qualifying method and an action method, and SOQL and DML are blocked in the per-record methods. Add-on interfaces such as ParentQuery, PriorParentQuery, RelatedQuery, OwnUnitOfWork, Bypassable, RecursionGuard, Finalizer and ContinueOnError extend these roles, for example to bulk-load parents and related records or to let a failing handler be logged without failing the save.

The author analyzed 919 SOQL queries from three projects and found that parent and config queries made up most of the total, which is why the framework bulk-loads parents once per chunk and recommends static variables for configuration data. Writers commit through DML Lib, which orders inserts by dependency and performs one DML per operation and object type at the end of the run. The article is cut off during its discussion of the Logger interface, so the logging details are not covered.

Read the original at Beyond the Cloud (opens in a new tab)

Worth reading?

RecommendedArchitecture

Salesforce Headless 360 exposes the platform to agents through APIs and MCP (opens in a new tab)

You will learn what Salesforce Headless 360 offers through its three access paths, why governance has to move from the UI to the schema, and how to start a controlled pilot with a Hosted MCP Server.

  1. Pick one workflow
  2. Audit the schema
  3. Connect a sandbox client
  4. Define agent identity and limits
  5. Test, trace and measure
A five-step plan for a first Headless 360 pilot

Salesforce Headless 360 is an architecture that exposes Salesforce capabilities through APIs, Model Context Protocol (MCP) tools and CLI commands, so AI agents, apps and developer tools can use the platform without a browser. Announced at TDX 2026, it keeps the data, workflows and business logic built over 25 years, and the company now also calls the offering Headless Toolkit. Salesforce cites more than 60 MCP tools, 30 preconfigured coding skills, 4,000 APIs and 220 CLI commands, and states that Lightning and the browser remain available for human users.

The piece explains three access paths. APIs serve developers and integration platforms that read and write records. MCP tools let AI clients such as Claude, ChatGPT and Cursor discover and call capabilities at runtime, with no custom integration code written in advance. CLI commands support scaffolding, testing and deployment through DevOps pipelines. MCP tools are further split between coding agents, which read metadata, generate Apex and deploy, and business agents, which reach Salesforce from Slack or other chat clients. Hosted MCP Servers became generally available in April 2026, and the Headless 360 MCP Server followed in beta in July 2026. Every Hosted MCP call runs as the authenticated user through an External Client App with the mcp_api scope, and the article warns that pricing via Flex Credits may bill for usage, so teams should confirm terms with their account team.

For architects, the central change is that governance moves from the screen to the schema. An agent never sees a page layout, so Validation Rules, sharing models, Apex and approvals must carry the controls. The article proposes a four-layer view of experience, access, execution and data, and lists review questions about rule placement, least-privilege Permission Sets, human-only actions and approval points for high-risk actions. It also covers the Headless Experience Layer and Multi-Framework support for React, and notes that agent testing needs evaluation sets, session tracing and the Agentforce Testing Center. MuleSoft supplies governed access to systems outside Salesforce, while Data 360 supplies unified customer context.

The article suggests starting with one workflow, auditing the schema, connecting a sandbox Hosted MCP Server to one client, defining agent identity and limits, and then testing, tracing and measuring results against the manual process. It treats vendor customer stories as reference points only and advises a pilot to generate real evidence.

Read the original at Cloud Odyssey (opens in a new tab)

Worth reading?

RecommendedAgentforce and AI

Poor agent context inflates token use and Flex Credit spend (opens in a new tab)

You will learn how weak business context makes Salesforce agents burn far more tokens, and which low-cost habits (documenting objects, defining terms, cleaning records, using Flow where no reasoning is needed) reduce that cost before Headless Platform Interaction metering starts.

  • 43,000: Tokens used without the harness, with a wrong answer
  • 7,000: Tokens used with the configured harness
The same question used far fewer tokens once the agent had proper business context

A Dreamforce demo followed a sales rep asking an agent which customers to focus on to close a Q3 gap. Without a harness, the agent used 43,000 tokens and gave a wrong answer: it recommended a frozen customer, missed a renewal already in the pipeline, and misread fiscal Q3. With a properly configured harness that pulled live pipeline data, used a semantic layer to define Q3, and drew on memories of past customer interactions, the same question took 7,000 tokens and produced a sound answer.

The article argues that Flex Credit burn comes largely from the context an agent must work out for itself. Outcome-based pricing and the planned charge for Headless Platform Interactions make this matter, since the meter runs whether or not the answer is good. No multiplier has been published yet, and Salesforce has promised 30 days’ notice before metering starts. Context packs let a harness supply only the subset of information an agent needs, so the aim is the right context rather than the most context.

The author suggests practical steps for now: fully document the one or two objects agents will rely on most, write down ambiguous definitions such as fiscal quarters, clear stale and duplicate records, use a plain Flow where a deterministic answer is enough, and record a consumption baseline before metering gets more complicated.

Read the original at Salesforce Ben (opens in a new tab)

Worth reading?

RecommendedAgentforce and AI

Salesforce Agent Fabric adds cross-platform evals, due January 2027 (opens in a new tab)

You will learn what Salesforce's planned Agent Evals and API Evals do, how the availability timeline looks, and how they compare with evaluation tools already on the market.

Why read this

You will also see where the promised features are still only roadmap.

  1. Define what the agent should and should not do
  2. Generate a test set from requirements
  3. Grade results with an LLM judge and data checks
  4. Quarantine the agent if quality thresholds fail
Agent Evals workflow as described for the January 2027 general availability

Vernon Keenan, writing for SalesforceDevops.net, reviews Salesforce’s Agent Fabric update, which adds Agent Evals and API Evals to its agent control plane. Agent Evals is pitched as working across any platform: it generates tests before deployment, scores production agents against quality thresholds, and can trigger a kill switch. API Evals generates functional and performance tests from API specifications so breaking changes are caught early. Salesforce’s earlier Agentforce Testing Center, generally available in February 2025, covered only Agentforce agents.

The availability timeline matters. Agent Evals and API Evals target beta in November 2026 and general availability in January 2027, and the triggered kill switch also targets January 2027. What is generally available today is the defensive layer: a manual kill switch, a FinOps dashboard, Model Wallet budget limits, cost optimization policies, and federated gateway policies. Salesforce says the policies cut token usage by up to 75% in test scenarios, which Keenan treats as a best case. Cross-platform LLM and MCP server evals are still labeled “coming soon,” and Salesforce has not confirmed live-traffic scoring. Keenan argues that enterprises are buying the control plane mainly to manage sprawl, while orchestration features wait on customers’ workflows.

Keenan compares the offering with tools already on the market, including Arize Phoenix, LangSmith, Langfuse and Braintrust, which offer evals and tracing, some with online scoring. He also cites AWS AgentCore Evaluations, Google Cloud agent evaluation, IBM watsonx Orchestrate and ServiceNow AI Control Tower, which has a kill switch that revokes credentials. Developer tools instrument the agent’s own build, while Agent Fabric governs agents its customers did not build and can pause them. A key unanswered question is whether Agent Evals will show step-level traces for third-party agents, since a failing score without a trace explains little.

In his closing section, Keenan urges Salesforce to make evals the centerpiece. His recommendations include shipping a versioned test suite with each context pack, making eval libraries exportable in open formats, grading live traffic with linked traces, and bringing Testing Center customers into Agent Evals. He also asks Salesforce to publish a reproducible benchmark before the January general availability, comparing a frontier model alone, the same model with equivalent data access, and the model using the Enterprise AI Harness.

Read the original at SalesforceDevOps.net (opens in a new tab)

Worth reading?

Data Cloud

Eight practices for building a performant Tableau Semantics model (opens in a new tab)

You will know how to structure a Tableau Semantics model for query speed, correct joins, governance and scale, and which build path suits your situation.

Why read this

The piece is practical guidance rather than a release announcement.

  1. Business-driven design and conceptual modeling
  2. Choose a build path
  3. Implement and test iteratively
  4. Design for query performance
  5. Centralize security and standardize
Five groups of practices for building a performant semantic model, in the order the article presents them

The article argues that a semantic model should reflect business concepts rather than database schemas, and that conceptual modeling and stakeholder review should come before joins are configured. It describes three build paths: generating a model from natural language with Tableau Agent, generating one from existing CRM Analytics or Tableau Cloud data, and extending a verified model through composable modeling. It recommends starting from the Salesforce Customer 360 Semantic Model where applicable.

For performance, the guidance is to keep runtime joins to about six or seven, avoid many-to-many joins and expensive operators such as BETWEEN, join on primary keys, set explicit join cardinality, and align default filters with Data Lake Object partitioning. Secondary indexes and pushing heavy transformations upstream into Data 360 batch transforms or Calculated Insights are suggested for very large datasets. Security should be enforced through Data 360 Policies rather than model filters, which are meant for business relevance and can be bypassed by ad-hoc queries.

The piece also advises testing with the Test Model feature and visual checks for join fan-outs, and stress testing against production-scale volumes and concurrent query patterns before rollout.

Read the original at Salesforce Blog (opens in a new tab)

Worth reading?

Data Cloud

Data 360 connects to Snowflake through Zero Copy without moving data (opens in a new tab)

You will learn what the Zero Copy v2 connector exposes in Snowflake, which pieces are generally available versus in preview, and how governance and private connectivity are handled across the two platforms.

  1. Connect enterprise data
  2. Give it shared meaning
  3. Turn it into trusted context
  4. Act on it in agents
Data moves from enterprise data to action in four stages, as the article frames Data 360's role

Salesforce describes Data 360 as a context layer for AI agents, and presents its Zero Copy partnership with Snowflake as the way to reach governed data where it already lives rather than copying it through ETL pipelines. The article reports more than 1,000 joint customers running workloads with native Zero Copy, and presents this as the basis for Agent Context Engine, which combines structured data, unstructured content, knowledge graphs and agent memory.

The technical changes are the substance here. The v2 Zero Copy connector presents Data 360 objects as native Apache Iceberg tables inside a customer’s Snowflake account, queryable with SQL and usable with Streams and Dynamic Tables for near real-time change capture. OpenID Connect authentication secures access. Expanded Zero Copy with Horizon Catalog adds direct file federation with Snowflake-managed Iceberg tables, and Data 360 Private Connect Multicloud allows Data 360 on AWS to reach Snowflake on Azure without public internet traffic.

Availability is staged. The v2 connector and Private Connect for Snowflake on Azure are generally available, Expanded Zero Copy with Horizon Catalog and Snowflake Cortex Agents are in public preview, and the Salesforce and Informatica MCP servers in Cortex are in private preview. Tableau support for Snowflake semantic views is planned for general availability in early 2027.

Read the original at Salesforce Blog (opens in a new tab)

Worth reading?

Architecture

How Salesforce uses headless patterns internally, and how to apply them (opens in a new tab)

You will learn how Salesforce applies headless architecture to agents, customer-facing experiences and internal tooling, and the three components it considers necessary for a trusted headless agent.

Why read this

You will also see the reported gains from building on Multi-Framework with React.

  1. Ground in business context via Data 360
  2. Interpret requests and act through tools
  3. Build governance in from the start
The three baseline components Salesforce uses to build a trusted headless agent

Salesforce presents its Headless Toolkit and AIforce as a way to bring platform capabilities, security and business context to any surface where work happens, rather than confining them to a single standard UI. The post follows its “Customer Zero” principle and describes four internal uses: an IT support agent that runs in Slack and a self-service portal on the same Flows and governance, a security and access agent that calls tools exposed by the Salesforce MCP server, a Headless Experience Layer playground for building widgets with mock data, and a React app that monitors a 15,000-engineer internal org.

The post says a trusted headless agent needs three baseline components: grounding in business context through Data 360, the ability to interpret requests and act through tools, and governance built in. It also reports that Builder Central’s frontend was rebuilt in React on Multi-Framework in a two-week sprint, where the previous stack would have taken two to three months, and that the development inner loop dropped from minutes of build and sync time to seconds.

Most of the piece is positioning and promotion, and it gives few concrete measurements or code. The architectural pattern of building logic once and exposing it through several surfaces is the useful takeaway for architects, with the timing claims as Salesforce’s own account.

Read the original at Salesforce Blog (opens in a new tab)

Worth reading?

Releases

Salesforce's Braze acquisition raises questions for Marketing Cloud teams (opens in a new tab)

You will learn what the announced Braze acquisition means for Marketing Cloud Engagement and Marketing Cloud Next, and which skills and architectural decisions it may affect.

Why read this

The article also makes clear that no combined roadmap exists yet.

Marketing Cloud Engagement

  • Relies on Journey Builder
  • Established automation offering

Marketing Cloud Next

  • Emphasises Data 360 and AI
  • Automation through Flow Builder
The two Marketing Cloud platforms the Braze deal must fit alongside, as the article describes them

Salesforce has agreed to acquire Braze, an engagement platform that reacts to customer behaviour in real time across email, push, in-app messaging, SMS and WhatsApp, in a deal valued at around $5.66B. Salesforce expects to close during fiscal 2028, subject to shareholder and regulatory approval. Braze says in an SEC filing that its integration with Data 360, Customer 360 and Agentforce remains a possibility and that no decisions have been made.

The article notes that Salesforce has not published a combined roadmap showing how Braze’s capabilities will overlap with Marketing Cloud Engagement, which relies on Journey Builder, and Marketing Cloud Next, which centres on Data 360, AI and Flow. Salesforce’s president of applications and marketing suggested Braze would extend Marketing Cloud Next with real-time, mobile-first engagement rather than replace Marketing Cloud.

For practitioners, the piece argues that the greatest risk is over-specialising in one orchestration tool, and that event tracking, identity, API integration and data architecture skills will grow in value. It also expects consulting work around integration, migration and platform rationalisation, while warning that pricing, packaging and third-party integration openness remain unknown.

Read the original at Salesforce Ben (opens in a new tab)

Worth reading?

Flow and admin

Choosing between roll-up summaries and Formula Fields in Salesforce (opens in a new tab)

You will know when a value needs a roll-up summary, a Formula Field, or a Flow or Apex alternative, based on relationship type and the shape of the calculation.

Why read this

The piece ends with a short decision checklist.

Roll-up summary

  • Aggregates child records
  • Master-detail only
  • Recalculates on child change
  • No lookup relationships

Formula Field

  • Uses one record's fields
  • Lookup or master-detail
  • Recalculates on each view
  • Never stale at read time
Roll-up summaries and Formula Fields differ in what they calculate and where they work

The article distinguishes roll-up summary fields from Formula Fields. A roll-up summary sits on a parent record and aggregates its child records through count, sum, min or max. It works only on master-detail relationships and recalculates when a child changes. A Formula Field calculates from a single record’s own fields and related parent fields, recalculating each time the record is viewed, and works on both lookup and master-detail relationships.

Roll-ups suit jobs such as counting open cases on an account or summing opportunity amounts, and they stay accurate without extra queries or flows. Their limits are basic filter criteria, no more than one relationship level, and no support for lookup relationships. Formulas suit record-level logic such as age fields, name concatenation or flags driven by a few fields. The trap is formulas that reach across many objects, which become hard to read and can slow List Views and reports on large data volumes.

The article closes with a checklist: many children into one parent number points to a roll-up, a value derived from the record itself points to a formula, a lookup relationship needs Flow or similar tooling, and complex filtering or cross-object aggregation needs Flow or Apex.

Read the original at dev.to (opens in a new tab)

Worth reading?

In brief