The independent daily for Salesforce admins, developers and architects

Curated by Abhinav (opens in a new tab)

Recommended

Understanding the new Apex heap limits and transition settings in Winter '27 (opens in a new tab)

Readers will learn the exact new synchronous and asynchronous Apex heap limits in Winter Twenty Seven and how to configure non-production orgs during the transition.

Why read this

The piece also explains how larger memory allocations impact transaction scaling, user experience, and downstream system stability.

The Winter Twenty Seven release increases the synchronous Apex heap limit from six megabytes to ten megabytes and raises the asynchronous limit from twelve megabytes to twenty-five megabytes. To manage the transition safely, administrators can use Apex Settings to force non-production orgs to retain the previous Summer Twenty Six limits until code is verified against the new thresholds.

Testing with large compressed files shows that the additional memory allows significantly larger payloads to be processed in a single transaction, though compression algorithms and file structure still dictate actual heap consumption. The author notes that higher memory availability does not automatically improve throughput, as CPU limits and governor constraints remain unchanged.

Larger heaps introduce risks such as overwhelming end users with unfiltered data tables, overloading downstream APIs, or masking existing logic flaws that previously failed at smaller record counts. The article concludes that developers should continue writing code that conserves resources and batches workloads, treating the increased limits as capacity for legitimate growth rather than a target to hit routinely.

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

Worth reading?

Using Apex frameworks to enforce code quality and platform limits in the AI era (opens in a new tab)

Readers will learn how to structure Apex libraries with strict interfaces and runtime validations to prevent both human and AI errors.

Why read this

The piece also explains how these patterns automatically optimize SOQL and DML usage to stay within Salesforce governor limits.

The article, written by Piotr Gajek, a Senior Salesforce Developer and Technical Architect, introduces Framework-Driven Development (FDD), an approach developed over a couple of years in his Apex Fluently libraries. Its core idea is to move responsibility for code quality and Salesforce governor limits out of individual developers and AI agents and into shared frameworks and the development process. He argues that LLM output is statistically average and often disconnected from the wider architecture, and that shared limits on an org mean one team’s careless generated code can break another’s solution. He describes the phenomena of “meat proxies” and “slop grenades” as reasons why ownership of code becomes unclear.

The approach rests on three rules: frameworks should be idiot-proof and AI-proof, generated code should be optimized for platform limits, and quality should be built in by design. Idiot-proofing uses limited interfaces that expose only permitted methods, such as the SOQL Lib cache module that blocks toList() because of misleading cached results, and the Trigger Lib contexts that allow only relevant actions per trigger phase. Internal validation throws explanatory exceptions with suggested overrides, and documentation and AI-readable skills act as a final safeguard.

For limits, the author highlights Async Lib, which manages queueable, schedulable and batch jobs to avoid the “Too many queueable jobs” error; DML Lib, which builds a dependency graph and commits records in optimized order through a shared Unit of Work; SOQL Lib, which caches queries in static, org or session scope; and Trigger Lib, which batches parent queries from many handlers. Quality by design is reinforced by phase-specific rules and small, single-responsibility classes. He also suggests administrators could benefit when Apex-based logic replaces Record-Triggered Flows. The conclusion recommends combining libraries, context documents and layered testing, with TDD where useful.

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

Worth reading?