The independent daily for Salesforce admins, developers and architects

Curated by Abhinav (opens in a new tab)

Must-read

Running Apex tests in CI without a Scratch Org, with gated deploys (opens in a new tab)

You will see how Apex tests can run on a CI runner against a local runtime, what a gated deploy with a check-only validation looks like, and the trade-offs of keeping the org only for the final deploy.

Why read this

The piece is also a product pitch for renmy, so weigh its benchmark claims accordingly.

  1. Run local runtime gates on the bundle
  2. Check-only validation of the same bytes
  3. Deploy to the target org
The gated deploy sequence renmy deploy follows before any metadata reaches the org

The piece argues that most Salesforce CI pipelines waste time and reliability on provisioning a Scratch Org or shared sandbox just so Apex tests have somewhere to run. Its proposed alternative is renmy runtime, a local Apex runtime that executes Apex, SOQL, DML and Salesforce Flows on the CI runner itself, backed by an embedded PostgreSQL database. The author says this removes the need for a JWT certificate, a Dev Hub allocation or a Scratch Org for the unit-test job, and that tests finish in seconds with JUnit XML and Cobertura coverage output. The runtime is presented as an interpreter that enforces governor limits and platform rules, not a mock framework or a transpiler. The piece includes a GitHub Actions example in which the only secret needed is a license key, and it notes that tests can keep running during a Salesforce incident even though deploys cannot.

The piece also describes a gated deploy command, renmy deploy. It snapshots the source into a content-addressed bundle, runs the local test and coverage gates against those exact bytes, then runs a real check-only validation of the same bytes in the target org, and deploys only after that succeeds. A coverage floor can be set with a minimum-coverage flag. For teams that need an approval step, a release command validates and writes a receipt containing the bundle digest, git revision, org fingerprint, gate results and validation job id. After approval, a deploy step quick-deploys the validated job within Salesforce’s 10-day window, or resends the stored bundle, and rejects changed, expired or wrong-org receipts. The author also covers pinning the Salesforce CLI version and recovering deploys stuck in the org’s Pending queue.

The author is candid that the org still matters for anything a person inspects, for integration tests against real endpoints, and for the final validation and deployment. The main claim to weigh carefully is the vendor’s own benchmark: about 1 minute 46 seconds to deploy and run 837 tests in an org against 2.4 seconds locally, roughly 45 times faster, with all tests passing in both. The method is published by the vendor and has not been independently verified in the piece. Branch coverage is reported locally but not by the org, so the two coverage figures are not directly comparable. The piece also notes that the Team tier, which covers CI runner use, is free during the public beta, with a listed price of $49 per developer per month, and that an individual Free tier exists.

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

Worth reading?

Recommended

What a local Apex runtime sends off the machine, and what it keeps (opens in a new tab)

You will know where Apex source, test data and licence details go when renmy runtime runs, which settings turn telemetry off, and how it works offline and air-gapped.

Why read this

It is the questionnaire answers a security or procurement team will ask for.

Org-based test runs

  • Each test run deploys to a Salesforce org
  • Test data sits in the org sandbox
  • Each developer needs an org credential

Local runtime

  • Tests run on the developer's machine
  • Test data lives in an in-process database
  • Test runs need no org or credential
Where Apex runs and where data lives, before and after a local runtime

This vendor-written piece, published by Renmy UG of Berlin, gives security and procurement teams the answers they need for a questionnaire about renmy runtime, a local Apex runtime formerly called Nimbus. It executes Apex, SOQL, DML and Salesforce Flows on a developer’s machine against an embedded PostgreSQL, without an org, Docker or a JVM. Apex source is read locally and sent to no one. Tests run against schema read from the project’s metadata, so they need no connected org, and test data sits in an in-process database with no open network port, rolled back after each test.

The article then sets out what leaves the machine. The Free tier needs no network access. By default the runtime sends one privacy-minimal activation event to an EU-hosted service, which excludes code, paths, test names and record data. Pro licences also record one de-duplicated activation from headless CI. Either can be switched off with a single setting or environment variable. Pro and Team licence checks send the licence key to the Keygen licensing API, at most once a day. Activating a machine with renmy login also sends a hashed installation ID, hostname, display name, OS, architecture, CPU core count and account ID. Licences are cached for offline use for up to seven days.

For disconnected networks, the article says the binary can be copied into place without internet access, since the database engine is embedded, and the daily update check can be disabled. Enterprise customers can have licence validation on premises, with pricing from $20,000 a year. A command-by-command table lists what each command contacts. The Salesforce org remains the system of record and deployment target. The deploy flow validates the same payload in the org before deploying, and Pro release commands produce signed receipts for auditors.

The piece closes with a list of documents to attach to the questionnaire, including the security page, data processing addendum, subprocessor list and licence terms. It also gives pricing: Free at $0, Pro and Team free during the public beta with listed prices of $19 and $49 per month, and Enterprise on a custom contract.

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

Worth reading?

Must-read

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?

Must-read

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?

Must-read

Running Apex tests locally so AI coding agents can iterate on them (opens in a new tab)

You will learn why coding agents stall on Apex when every test run needs a Salesforce org, and how a local Apex runtime exposed through an MCP server gives an agent a fast write-run-fix loop.

Why read this

You will also see the boundary the article draws around deployment.

Against an org

  • Deploy class to an org
  • Wait, then start test run
  • Poll until finished
  • Minutes per cycle

Against a local runtime

  • Run tests on the machine
  • Read structured results
  • Fix and rerun
  • Seconds per cycle
Agent loop against a Salesforce org versus against a local Apex runtime

The article argues that AI coding agents stall on Salesforce Apex because Apex only runs inside a Salesforce org, so each test cycle means deploying, waiting, polling and parsing logs, which can take minutes and requires org credentials. Agents then either stop iterating and hand back untested code, or keep going at a high cost in time and tokens. The author’s published benchmark puts four open-source Apex suites, 837 tests in total, at about 1 minute 46 seconds to deploy and run in an org, against 2.4 seconds locally. The piece also notes that Nimbus was renamed renmy runtime in October 2026, with the same binary and the MCP server name nimbus kept.

The proposed fix is renmy runtime, a local Apex runtime that executes classes, triggers, SOQL, DML and Salesforce Flows against an embedded PostgreSQL, with no org, sandbox, Docker or JVM. The author says it enforces governor limits and mirrors platform behaviour such as Test.startTest and Test.stopTest, and that it is not a mock or a transpiler, though it does not achieve perfect parity. Its renmy mcp command runs as a stdio child process of the agent, so no port or credential is needed. The exposed tools include run_apex_tests, explain_failure, get_coverage, get_execution_trace, execute_anonymous and list_test_classes, which return structured results rather than logs to parse. Setup is a one-line install, a test run in the project, and registration with Claude Code, Cursor or GitHub Copilot.

A worked example shows an agent adding a discount rule to an invoice service: it lists existing tests, writes a method and test, runs the suite, uses the failure explanation to find a status filter bug, fixes it, and uses coverage to add a boundary test, all within seconds and without touching an org. The author also connects this to Salesforce Headless 360, where Apex hooks such as InvocableMethod and RestResource become tools for Agentforce or external agents, and says the runtime can test that underlying Apex offline.

The article draws a firm boundary around deployment. A green local run is necessary but not sufficient, because the org holds Permission Sets, managed packages, Validation Rules and other teams’ automation that a repository does not contain. The agent should not deploy on its own. renmy deploy runs local gates, then a real check-only validation in the org before deploying, while renmy release validate and renmy release deploy add a human approval step and an immutable receipt between the two. The Free tier covers unlimited local test runs, and the MCP server is a Pro feature that is free during the public beta.

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

Worth reading?

Recommended

Running Apex tests on a local runtime, without an Org round trip (opens in a new tab)

You will learn what renmy runtime does, how it runs Apex and Flows locally against an embedded PostgreSQL, and which commands cover testing, debugging, AI agent integration and gated deploys.

Why read this

You will also see what the benchmark claims and what sits behind the Pro tier.

  1. Snapshot selected source into a bundle
  2. Run local validation and test gates
  3. Check-only validation in the target org
  4. Deploy the validated bundle
The gated deploy path from local source to the Salesforce org

Nimbus has been renamed renmy runtime, with the same tool and the same binary. It is a local Salesforce Apex runtime that executes real Apex, SOQL, DML and Salesforce Flows on a developer’s machine against an embedded PostgreSQL database. The runtime enforces platform rules such as governor limits, order of execution across triggers and flows, and per-test transaction isolation. It ships as a single binary for macOS, Linux and Windows and needs no org, Scratch Org, Docker or JVM.

The article’s benchmark compares four open-source Apex suites containing 837 tests. Run in a Salesforce org, they took about 1 minute 46 seconds, and locally they took about 2.4 seconds, roughly 45 times faster, with every test passing in both places. Around the runtime sit a language server that serves editors such as VS Code, Cursor, Neovim, Zed and JetBrains IDEs, a live debugger that supports breakpoints and stepping, and line and branch coverage reporting. Pro adds mutation testing, which the author says is the first of its kind for Apex, and watch mode. The toolkit also includes failure explanation and triage tools, a browser-based Dev UI, and a flaky-test finder.

For AI coding agents, renmy provides an MCP server with tools for running tests, executing anonymous Apex, reading coverage and explaining failures, so agents can verify Apex locally before anything reaches an org. The deployment path is gated: renmy deploy is free and snapshots the source, runs local tests and coverage gates, validates the same bytes in the target org with a check-only validation, and then deploys. The Pro renmy release commands split validation from deployment and produce a receipt that records the bundle digest, Git revision, gate results and the validation job ID, so a team can approve and deploy the validated payload from another machine. The article stresses that Sandboxes remain useful for end-to-end checks and user-facing testing.

The Free tier costs nothing without a card and covers unlimited local test runs, gated deploys, Salesforce CLI pass-through and IDE integrations on one machine. Pro, which adds the daemon, parallel runs, debugger stepping, mutation testing and the MCP server across three machines, and Team are both free during the public beta. Their list prices are $19 per month and $49 per developer per month, and Enterprise starts at $20,000 per year.

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

Worth reading?

Must-read

How a local Apex runtime speeds up testing without replacing your org (opens in a new tab)

You will learn how a local runtime executes Apex and Flow metadata against an embedded database while enforcing governor limits and order of execution.

Why read this

The article explains how this approach accelerates the edit-test cycle and fits into your standard deployment workflow.

Local Apex runtime

  • Apex interpreter
  • Local database for SOQL and DML
  • Rule engine for limits and execution
The local Apex runtime is built from three core components

The article, written by the maker of renmy runtime (formerly Nimbus, renamed in October 2026), introduces a local Apex runtime: a program that executes Apex, SOQL and DML on a developer’s own machine without a Salesforce org. It argues that Salesforce developers work in a slow loop, where every edit is deployed to an org and tested there, while developers in Java, JavaScript and Go run tests locally in about a second. The author attributes this gap to Apex being multi-tenant and tied to the platform’s data model and order of execution. Cited costs include round trips to the org, CI that needs org credentials, outages that halt testing, and AI coding agents that cannot iterate quickly. A local runtime has three parts: an Apex interpreter, an embedded PostgreSQL database for real queries and DML, and the platform’s rules, including enforced governor limits, triggers and Flows in order of execution, and per-test rollback. A sample test runs in tens of milliseconds, and the article says the runtime is not a mock, not a Scratch Org and not a transpiler.

The article is clear that a local runtime does not replace the org. Lightning pages, user-facing Screen Flows, permission checks, real integrations and the deploy itself with Salesforce’s metadata validation still happen in the org. The author compares this to a Java team’s staging environment, which stays for integration and final checks but is not the only place code runs. The renmy deploy is described as running local test and coverage gates first, then a check-only validation in the target org, then the deploy. The tool also offers coverage reporting, mutation testing, a debugger in VS Code and JetBrains, an MCP server for AI coding tools, and an IDE plugin. A published benchmark reports that 837 tests from four open-source suites ran in about 2.4 seconds locally versus about 1 minute 46 seconds in an org, with all tests passing in both.

Installation is a single binary for macOS, Linux and Windows, with no JVM, Docker or org required, and the commands are renmy test “” from the project root, plus options for single classes, coverage and a browser dev UI. The free tier covers individual developers, while Pro and Team tiers are free during the public beta and listed at $19 per month and $49 per developer per month. The article links to a parity record, which it describes as not a claim of 100 percent accuracy, and to GitHub for issues and releases.

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

Worth reading?