Andrii Sukhetskyi’s Post

🌩️ Ever seen your Salesforce code fail with “Too many SOQL queries”? That’s not a bug — that’s Salesforce teaching you efficiency 💡 Let’s talk about something every developer must master: Governor Limits in Salesforce 💭 What Are Governor Limits? Salesforce is a multi-tenant platform, meaning thousands of organizations share the same computing resources. To make sure one org doesn’t hog all the CPU, memory, or database power, Salesforce enforces Governor Limits , strict runtime caps on how much code can consume. 🚀 Why Are They Important? Governor Limits: 🔹Prevent a single org or user from overusing shared resources. 🔹Keep the platform stable for everyone. 🔹Encourage developers to write efficient, bulkified, and scalable code. 🔹If you exceed them, Salesforce throws a System.LimitException, and your transaction fails. 🧩 Types of Governor Limits 1️⃣ Per-Transaction Limits – e.g., SOQL, DML, heap size 2️⃣ Per-Org Limits – e.g., daily email limits, API calls 3️⃣ Static Apex Limits – fixed limits like batch size or queue depth 4️⃣ Size-Specific Limits – for data storage, fields, or payloads 💡 Pro Tip: Always bulkify your code — move SOQL & DML outside loops and use Maps/Sets to process records efficiently. #Salesforce #Apex #GovernorLimits #DeveloperCommunity #CareerGrowth #CodingBestPractices #TechLearning #SalesforceDeveloper

🚀 Salesforce Governor Limits 2025: Complete Reference Guide for Developers Struggling with unexpected Salesforce code failures? Understanding Governor Limits is crucial for writing efficient, scalable Apex code. Here's your comprehensive reference for all platform boundaries! 📊 🔍 Key Governor Limits (2025 Updated) Query Limits: • SOQL Queries: 100 (Sync) / 200 (Async) • SOQL Records: 50,000 • SOSL Queries: 20 • SOSL Records: 2,000 Processing Limits: • CPU Time: 10s (Sync) / 60s (Async) • Heap Size: 6MB (Sync) / 12MB (Async) • Callouts: 100 • Callout Timeout: 120s Data Limits: • DML Statements: 150 • DML Records: 10,000 • Email Methods: 10 • Push Notifications: 10 calls, 2,000 per call 💡 Top Best Practices to Avoid Limits 1️⃣ Bulkify Your Code - Handle multiple records in single transactions 2️⃣ No SOQL/DML in Loops - Move operations outside loops 3️⃣ Use Async Processing - Queueable, Future, or Batch Apex for heavy operations 4️⃣ Monitor Limits - Use Limits class to track usage proactively 5️⃣ Optimize Queries - Make SOQL selective with indexed fields 🛠️ Pro Tips for Developers • Use selective queries with indexed fields • Implement pagination for large datasets • Cache frequently accessed data • Optimize trigger logic with frameworks • Consider Bulk API for very large operations Perfect for Salesforce Developers, Admins, and Consultants looking to build robust, scalable applications! 💻✨ 🔍 For detailed examples, code snippets, and advanced strategies, check out my comprehensive guide: https://lnkd.in/gk_AjqrF For more Salesforce development tips and best practices, explore my work: 🔗 https://dev-nkp.github.io/ #Salesforce #GovernorLimits #Apex #SalesforceDevelopment #SalesforceAdmin #SalesforceDeveloper #SalesforceTips #CloudComputing #SalesforceLightning #ApexCode #SalesforceArchitecture #DigitalTransformation #SalesforceBestPractices #SalesforceOptimization #SalesforceProgramming

🔒 Why Salesforce Sharing Rules Matter Sharing rules control who can see and edit records, keeping your data secure. In Apex, you can enforce or bypass these rules: with sharing ✅ – Respects user permissions. Use for sensitive data. without sharing ⚠️ – Ignores permissions. Useful for system tasks, but handle carefully. inherited sharing 🔄 – Adapts to the caller’s context. Ideal for utility/helper classes. How Do You Decide Which Keyword to Use? The choice depends on your requirements: -Use with sharing when you need to honor user permissions and protect sensitive data. For instance, in customer-facing applications where users should only see their own records. -Use without sharing when permissions could interfere with critical processes like batch jobs or system integration. -Use inherited sharing for versatile utility classes that need to adapt dynamically. Tip: Always choose the right sharing context to balance functionality and security.

🚀 Exploring : insertAsync & updateAsync 🔹 What are insertAsync / updateAsync? • These methods let you insert or update external records (e.g., from AWS, Azure, SQL, or OData sources) without blocking your Apex transaction. • Salesforce queues the operation in the background — so your code keeps running while the system handles the remote request asynchronously. • You can even register a callback to manage post-operation logic, logging, or error handling when the async operation completes. 🔹 When to use it Use these methods whenever you need non-blocking CRUD operations on external objects — especially when external system latency or availability is unpredictable. 💡 Note: • These methods work only for External Objects, not standard Salesforce objects. • Continue using standard DML for internal records. 💡 How is this different from @future and Queueable Apex? • insertAsync() / updateAsync() are built for External Objects (__x), enabling async DML to external systems like AWS, SQL, or OData sources. • They don’t require a new Apex transaction — Salesforce handles the async operation internally. • You can register a callback to manage success/error once the external DML completes. • @future and Queueable are general async tools for background logic, not for direct external DML. • They run in a separate async context, meaning you handle chaining, error tracking, and retries yourself. • insertAsync and updateAsync help avoid timeouts and limits when dealing with slow external systems. #Salesforce #Apex #Integration #SalesforceConnect #AsyncApex #DeveloperLife Salesforce

If a user fills in the wrong field, skips a step, or clicks the “wrong” button… is it really their fault? Or did no one ever explain how the process actually works? Too often, Salesforce usage is designed with the assumption that users will just get it. That the flow will be intuitive. That the logic is obvious. But that assumption doesn’t hold up under pressure. If you want clean data and consistent behaviour, stop expecting users to reverse-engineer your build. Train them in the why, not just the where.

Every Salesforce admin knows that moment — a deployment goes live… and something breaks. No native rollback. No safety net. In Salesforce, once metadata changes are deployed, there’s no built-in “undo.” That’s why rollback isn’t just a feature — it’s a survival strategy. Here’s how teams handle it today: 🧩 Manual redeployment of old XML packages ⚙️ Version control snapshots (if you’re lucky) 🚫 No rollback across multiple orgs Now imagine doing that for 100+ customer orgs after an upgrade. 😬 ZuppIO changes this completely. ✅ Validation mode — test before you deploy ✅ Rollback snapshots — restore old configurations automatically ✅ Centralized logs — see what changed and when ✅ Multi-org deploys — fix everything at once Safe Salesforce releases aren’t luck — they’re automation. 🔗 Learn how ZuppIO prevents deployment disasters → https://zupp.io

Salesforce HTTP Callouts are a declarative game changer! Sure, there's a little prep work creating API keys, the Salesforce credentials and the JSON examples, but after that it's literally plug-and-play. I'm wholly impressed by this solution - it allows me to quickly solve so much of the "20%" of the 80/20 after major implementations, and with a little Claude AI help, I can get clever on scalable solutions that actually work. If you haven't used this in Flow yet, it builds the Apex for you to send the payload you design with the header bearer token you give it, does a little test and builds out the response code, lets you create variables against any of the values in the payloads and then you can pull the response variables to write to your own transaction records. I recommend creating a single object to carry the transactions from these to monitor these specific runs, and have your fault paths create fault records. #claudeai #salesforce #httpcallouts #api #faultpath

𝗦𝗮𝗹𝗲𝘀𝗳𝗼𝗿𝗰𝗲 𝗪𝗶𝗻𝘁𝗲𝗿 ’𝟮𝟲 𝗯𝗿𝗶𝗻𝗴𝘀 𝗺𝗲𝗮𝗻𝗶𝗻𝗴𝗳𝘂𝗹 𝘂𝗽𝗱𝗮𝘁𝗲𝘀 𝗳𝗼𝗿 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀, with a focus on performance, security, and consistency. Not every feature is production-ready. Separating what's GA from what’s still in pilot ensures better planning and delivery. 𝗞𝗲𝘆 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗛𝗶𝗴𝗵𝗹𝗶𝗴𝗵𝘁𝘀 : ✅ Confirmed / GA – Trusted Mode (LWS): Flexible API access for trusted scripts – Test Discovery: Unified testing for Apex and Flow – GraphQL for LWC: Modern, scalable data access – Stricter Modifiers: Enforced visibility for abstract/override methods 🔄 Pilot / Beta / In Progress – Lightning Out 2.0: Embed LWCs in external apps – ApexDoc Standards: Moves toward standardized documentation These improvements enable better coding practices, scalable testing and cleaner documentation. – Prabhat Sharma | 𝗦𝗮𝗹𝗲𝘀𝗳𝗼𝗿𝗰𝗲 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 #Salesforce #Winter26 #SalesforceDevelopers #LWC #Apex #FlowBuilder #TrustedMode #GraphQL #DevUpdates #SalesforceRelease #Alienbrainz

🚀 If you find Cursor (or other agents) keep struggling to read Salesforce documentation, this might help... I found that Cursor often trips up on Salesforce docs because of how those pages are built — shadow DOMs, dynamic loading, and other fun quirks. To get around this, I built a custom Cursor command using its 🧭 Browser Automation tool (you’ll need to enable it manually) to give Cursor a few more clues. The cool part? 🤖 Cursor actually helped write the fix once we figured out what was going on — it kind of wrote its own instructions. Use at your own risk, but it’s been working nicely so far. If you have found other ways around this or simply not encountered it - please share in the comments below. https://lnkd.in/g4grjx3V