Today4 stories · 5 briefs

The Daily Org

Spring '27Sandboxes 6 Feb 2027

Curated by Abhinav (opens in a new tab)

Vol. I · No. 24The independent daily for Salesforce admins, developers and architects4 stories · 5 briefs

Must-readDevOps

Testing Salesforce Flows locally with renmy runtime before activation (opens in a new tab)

You will learn how to run Record-Triggered Flows and Apex triggers on a local machine, catch order-of-execution overlaps before activation, and what the runtime does not cover.

  1. Retrieve flow into project folder
  2. Write test creating and closing record
  3. Run renmy test locally
  4. Fix overlap, rerun in seconds
  5. Activate and review in sandbox
A local test run replaces repeated sandbox rounds for checking flow and trigger behaviour

renmy runtime, formerly called Nimbus until its October 2026 rename, is a local Salesforce Apex runtime. It executes Apex, SOQL, DML and Salesforce Flows (Autolaunched, Record-Triggered and Screen Flows) on a developer’s own computer against an embedded database, with no org, sandbox or Scratch Org involved. The article argues that testing flows in a shared sandbox is slow and risky: other people’s automation fires alongside yours, test data disappears after refreshes, and overlaps between a flow and an Apex trigger on the same object often surface only after activation. Running locally, a Record-Triggered Flow fires together with the object’s triggers in the platform’s order of execution, so overlaps show up in milliseconds.

The article walks through an example: a Record-Triggered Flow that creates a follow-up Task when an Opportunity is set to Closed Won, alongside an older Apex trigger that also creates a Task. A developer retrieves the flow file into the project folder with the Salesforce CLI. They then write a short Apex test that creates an Account and an Opportunity, moves the stage to Closed Won, and asserts that exactly one Task exists with the expected subject. The admin can read that test as an acceptance criterion. Running renmy test with the test name, or with “” for every test, reports the result. If the trigger also creates a Task, the assertion fails with two Tasks, revealing the overlap. The fix is either to remove the trigger’s logic or to add an entry condition to the flow, and the rerun takes about a second. Once the flow is ready, renmy deploy runs the local checks before anything reaches the org.

The same runtime is available through a browser-based Dev UI started with renmy dev, which offers a test runner, schema browser and coverage explorer. A VS Code extension adds run buttons above each test, and a JetBrains plugin does the same in IntelliJ IDEA, including its Community edition, and can display a flow as a graph. The article is clear about the limits. The runtime executes a Screen Flow’s logic but does not render its screens, so layout, labels and conditional visibility must be checked in a sandbox with a user. It reproduces platform rules closely but is not Salesforce itself, and permissions, page layouts and user acceptance still require an org. The Free tier includes unlimited local test runs on one machine, with no account or card required.

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

Worth reading?

RecommendedData Cloud

Setting up zero-copy V2 between Salesforce Data Cloud and Snowflake (opens in a new tab)

You will learn the setup steps for the Zero-Copy V2 connector, including the enrollment code handoff, consumer grants and legacy schema aliases.

Why read this

You will also see where change tracking via streams failed in one test.

  1. Create connector and get Enrollment ID
  2. Create Snowflake V2 target in Salesforce
  3. Link Data Share to the target
  4. Mount shared data and grant access
The V2 setup runs between the Snowflake admin and the Salesforce admin in four steps

The author revisits connecting Salesforce data to Snowflake and reports that the V2 connector simplifies setup. The enrollment code replaces manual credential configuration, authentication uses OpenID Connect, and friendly names reduce SQL cleanup. Legacy schema aliases and grant comparisons before and after migration help keep existing access intact.

The walkthrough covers creating the connector and retrieving the Enrollment ID, then the Salesforce-side steps: creating a Snowflake V2 Data Share target, linking a Data Share to it, and mounting the shares in Snowflake as a linked database. It also covers granting usage and select privileges on existing and future views to the consuming role, and the choice between legacy and friendly naming.

The author’s incremental test did not work. A stream on an exposed view failed with a change tracking error involving unmanaged Iceberg tables, so current-state queries worked but change feeds did not through that path. The author recommends confirming the supported source object and stream setup, then testing inserts, updates and deletes end to end before relying on downstream history.

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

Worth reading?

Agentforce and AI

Pronto sample App shows how to build Headless Agentforce experiences (opens in a new tab)

You will see how one sample app wires Agentforce agents, custom MCP servers and HXL widgets together, and which tool types and latency trade-offs to weigh when exposing Salesforce logic to external clients.

  1. Agentforce agents and actions in the org
  2. Hosted MCP Servers expose the tools
  3. External Client App connects the client
  4. Third-party agent renders HXL widgets
How the Pronto employee assistant reaches users across surfaces

The Pronto sample app is an open-source example built on the Headless Toolkit, set around a fictional food delivery platform. It ships two Agentforce agents: an employee assistant and a customer service assistant. Both are orchestrator agents that share a storefront explorer assistant as a connected subagent, which shows how multi-agent orchestration can transfer conversations and reuse subagents without losing context.

The app also demonstrates exposing business logic through Salesforce Hosted MCP Servers. Its employee MCP server offers several tool types: Apex tools built from invocable actions, an Apex REST tool for storefront search registered through the API Catalog, and an Agentforce agent exposed as a custom MCP tool. The article notes that the agent-as-tool adds latency, because Agentforce makes further LLM calls after the first call to the MCP server.

Pronto is delivered to several surfaces from one codebase: an LWR Experience Cloud customer site, and external clients such as Claude, Slack and ChatGPT. Through the Headless Experience Layer Beta, the employee server can return rich HXL widgets, such as an order status card, which render the same way on each surface. Readers can create an External Client App, connect the server to a third-party agent, and deploy the source from GitHub to try it.

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

Worth reading?

Architecture

Seven architecture decisions for a Salesforce-Jira integration (opens in a new tab)

You will learn seven questions to settle before building a Salesforce-Jira integration, covering sync speed, reconciliation, field ownership, native versus middleware versus custom builds, error handling, scaling and governance.

Why read this

The piece treats the choice as a set of trade-offs rather than a product pick.

  1. Rep opens case in Salesforce
  2. Case syncs to Jira as an issue
  3. Developer investigates and resolves
  4. Resolution and Fix Version flow back
  5. Reconciliation corrects any missed updates
The case-to-issue flow between Salesforce and Jira, with the resolution returning to the rep

The article argues that a Salesforce-Jira integration is more than connecting two systems: when they drift apart, customers can see stale information before anyone notices the underlying fault. It presents seven architecture decisions to settle first. The first is how fast updates must move, with real-time event sync for urgent changes and queued asynchronous sync for routine ones, bearing in mind platform limits. The second is correctness: event-driven sync should be paired with scheduled reconciliation that finds mismatches and resends missing updates without duplicates. The third is field ownership, deciding per field which system owns the data so nothing is overwritten, and checking how comments, attachments and rich text map. The fourth is choosing native, middleware or custom builds, each with different trade-offs in limits, reporting, data residency, setup effort, maintenance and security. The fifth is error handling: limited retries, idempotent keys, alerts, monitoring, per-record history, and checking how each sync direction fails. The sixth is scale, planning for more users, projects and case spikes through batching, queues and awareness of memory limits. The seventh is where AI fits and who governs it, with AI assisting on suggestions and lookups while the sync itself stays deterministic and governed by named owners and human approval where needed.

Beyond these seven, the piece suggests three further checks before choosing an integration: the total cost of ownership over time, including who maintains it when Salesforce or Jira change; what support, SLA and escalation exist after go-live; and whether security teams can accept the credential handling and marketplace review. A decision matrix maps common situations to suitable routes, showing that most teams combine approaches rather than picking a single product.

The article concludes that there is no universal answer and that the right choice depends on workflows, integration needs and how much ownership a team wants to take on. It closes by asking every option the same key questions about missed events, field ownership, duplicate-free retries, alerting and maintenance. It also promotes Sinergify, a Salesforce-native Jira connector built around reconciliation-backed two-way sync, as one option for teams that prefer not to build and maintain this foundation themselves.

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

Worth reading?

In brief