Introduction
Salesforce implementation is fraught with challenges for business owners and programmers, including dealing with stringent governor limits, dynamic security models, and multi-system integrations.
To solve these integration challenges, workflow bottlenecks, and data migration problems, it becomes necessary to adopt an architectural approach based on best practices in architecture.
By analyzing some of the most frequent technical challenges along with their solutions, teams can enhance application performance and ensure data consistency.
Want to get better at configuring and developing on Salesforce? Check out our extensive Salesforce Course Syllabus to learn more about Salesforce Admin, Apex, LWC, and Integrations.
Salesforce Challenges and Solutions for Freshers
1. Hitting SOQL Governor Limits inside Loops
Challenge: SOQL queries inside loops are common among freshers. Given the multi-tenant limit enforced by Salesforce, where there can be 100 SOQL queries in one synchronous transaction, looping through records and executing SOQL queries within the loop will result in System.LimitException: Too many SOQL queries: 101.
Solution: Bulkification: Collect all IDs in a Set, perform one SOQL query, and then map the results.
Code Example: Java
// BAD: SOQL query inside loop (fails for > 100 records)
for (Account acc : Trigger.new) {
List<Contact> cons = [SELECT Id FROM Contact WHERE AccountId = :acc.Id];
}
// GOOD: Collect IDs and query once outside the loop
Set<Id> accountIds = Trigger.newMap.keySet();
List<Contact> cons = [SELECT Id, AccountId FROM Contact WHERE AccountId IN :accountIds];
2. Issuing DML Statements inside Loops
Challenge: Executing Data Manipulation Language (DML) operations, such as insert, update, or delete, inside loops quickly hits the governor limit of 150 DML statements per transaction.
Solution: Add modified records to a List collection inside the loop and perform a single batch DML operation outside the loop.
Code Example: Java
// BAD: Individual DML update per record
for (Opportunity opp : oppList) {
opp.StageName = ‘Closed Won’;
update opp;
}
// GOOD: Add to list and execute DML once
List<Opportunity> oppsToUpdate = new List<Opportunity>();
for (Opportunity opp : oppList) {
opp.StageName = ‘Closed Won’;
oppsToUpdate.add(opp);
}
if (!oppsToUpdate.isEmpty()) {
update oppsToUpdate;
}
3. Hardcoding Object and Record IDs
Challenge: Hardcoding 15-character or 18-character Salesforce record IDs (or Profile/Record Type IDs) directly into Apex or JavaScript breaks deployment when moving code between Sandbox and Production environments because IDs differ across orgs.
Solution: Fetch Record Types dynamically using Schema.SObjectType Describe results, Developer Names, or Custom Metadata Types.
Code Example: Java
// BAD: Hardcoded RecordType ID
Id devRecordTypeId = ‘0125g000000K123AAA’;
// GOOD: Dynamically retrieve Record Type ID by Developer Name
Id devRecordTypeId = Schema.SObjectType.Account.getRecordTypeInfosByDeveloperName()
.get(‘Enterprise_Customer’).getRecordTypeId();
4. Overstepping Mixed DML Exceptions
Challenge: Performing DML on Setup objects (e.g., User, UserRole, PermissionSet) and Non-Setup objects (e.g., Account, Contact) within the same synchronous transaction triggers a System.MIXED_DML_OPERATION error.
Solution: Isolate DML operations on Setup objects into an asynchronous execution context using @future methods or Queueable Apex.
Code Example: Java
public class UserHandler {
// Run setup object DML in an asynchronous context
@future
public static void assignPermissionSetAsync(Set<Id> userIds, Id permSetId) {
List<PermissionSetAssignment> psaList = new List<PermissionSetAssignment>();
for (Id uId : userIds) {
psaList.add(new PermissionSetAssignment(AssigneeId = uId, PermissionSetId = permSetId));
}
insert psaList;
}
}
5. Writing Non-Selective SOQL Queries on Large Data Volumes
Challenge: When an object contains tens of thousands of records, SOQL queries that filter using leading wildcards or non-indexed fields fail to use the Query Optimizer, leading to slow page renders or query timeouts.
Solution: Filter queries using indexed fields (e.g., Id, External ID, CreatedDate, or custom indexed fields) and avoid leading wildcards in LIKE expressions.
Code Example: Java
// BAD: Non-selective query using leading wildcard (scans entire table)
List<Contact> contacts = [SELECT Id FROM Contact WHERE Email LIKE ‘%@gmail.com’];
// GOOD: Selective query using indexed fields and target values
List<Contact> contacts = [SELECT Id, Name FROM Contact WHERE AccountId = :accId AND IsActive__c = true];
6. Misunderstanding Trigger Execution Flow and Recursion
Challenge: Triggers updating records can re-trigger themselves in an infinite loop (e.g., an after update trigger firing another update on the same object), leading to System.LimitException: Maximum trigger depth exceeded.
Solution: Use a static class variable as a guard flag to monitor execution and prevent recursive calls.
Code Snippet: Java
public class AccountTriggerHandler {
// Static boolean persists across execution context to prevent recursion
public static Boolean isFirstRun = true;
}
// In Trigger:
trigger AccountTrigger on Account (after update) {
if (AccountTriggerHandler.isFirstRun) {
AccountTriggerHandler.isFirstRun = false;
// Execute logic safely…
}
}
7. Ignored Field-Level Security (FLS) & Object Permissions in Code
Challenge: By default, Apex code runs in the system context and ignores user Profile permissions and Field-Level Security (FLS). Beginners often expose sensitive data by failing to check access permissions.
Solution: Enforce User Mode security using the WITH USER_MODE clause in SOQL or checking Schema.sObjectType accessibility.
Code Snippet: Java
// BAD: Bypasses user object and field permissions
List<Opportunity> opps = [SELECT Id, Amount, Credit_Card__c FROM Opportunity];
// GOOD: Enforces object and field level security at runtime
List<Opportunity> opps = [SELECT Id, Amount FROM Opportunity WITH USER_MODE];
Explore more with our Salesforce training in Chennai.
8. Imperative LWC Data Fetching without Reactive Provisioning
Challenge: In Lightning Web Components (LWC), manually making imperative Apex calls on every UI event causes unnecessary server overhead and inconsistent UI state rendering.
Solution: Use the @wire service to provision data automatically and keep the DOM in sync with backend changes.
Code Snippet: JavaScript
import { LightningElement, wire, api } from ‘lwc’;
import getAccountDetails from ‘@salesforce/apex/AccountController.getAccountDetails’;
export default class AccountCard extends LightningElement {
@api recordId;
// GOOD: Reactive data binding with @wire service
@wire(getAccountDetails, { accountId: ‘$recordId’ })
account;
}
9. Writing Tests Dependent on Existing Org Data
Challenge: Beginners often create test classes using @isTest(seeAllData=true) or assuming specific records exist in the org. This causes unit tests to fail when deployed across different sandboxes or production.
Solution: Isolated test classes must generate their own mock data in memory or use @testSetup methods.
Code Snippet: Java
@isTest
private class AccountServiceTest {
@testSetup
static void setupData() {
// Create isolated test record
Account testAcc = new Account(Name = ‘Test Corp’);
insert testAcc;
}
@isTest
static void testAccountFetch() {
Test.startTest();
Account acc = [SELECT Id, Name FROM Account WHERE Name = ‘Test Corp’ LIMIT 1];
System.assertEquals(‘Test Corp’, acc.Name, ‘Account name should match’);
Test.stopTest();
}
}
10. Mixing Declarative Automation with Triggers (Process Overlap)
Challenge: Creating Salesforce Flows and Apex Triggers on the same object without a central architecture leads to unpredictable execution order, duplicate processing, and delayed transaction save times.
Solution: Enforce a single automation strategy per object (e.g., using a single One-Trigger-Per-Object pattern with a framework like fflib alongside clear Flow trigger boundaries).
Code Snippet: Java
// Centralized Trigger routing logic
trigger OpportunityTrigger on Opportunity (before insert, before update, after insert, after update) {
// Route all trigger actions through a single handler class
OpportunityTriggerHandler handler = new OpportunityTriggerHandler();
handler.run(); }
Salesforce Challenges and Solutions for Experienced Candidates
1. Enterprise Transaction Frameworks & Re-Entrancy Locks
Challenge: Massively scaled Salesforce architecture with several asynchronous threads and complicated business logic is likely to have unexpected trigger recursion, re-entrancy issues, and race condition problems. Simple static boolean flag solutions will not work for complex multi-event operations and dynamic bulk chunks.
Solution: Introduce an enterprise-level Trigger Handler system by implementing a transaction-based registry with a set of processed record IDs for each execution phase.
Code Snippet: Java
public class TriggerContextManager {
private static Map<String, Set<Id>> processedRecordsMap = new Map<String, Set<Id>>();
public static Boolean isRecordProcessed(String contextKey, Id recordId) {
if (!processedRecordsMap.containsKey(contextKey)) {
processedRecordsMap.put(contextKey, new Set<Id>());
}
return processedRecordsMap.get(contextKey).contains(recordId);
}
public static void markRecordProcessed(String contextKey, Id recordId) {
if (!processedRecordsMap.containsKey(contextKey)) {
processedRecordsMap.put(contextKey, new Set<Id>());
}
processedRecordsMap.get(contextKey).add(recordId);
}
}
2. High-Volume Data Chunking & Stateful Batch Chaining
Challenge: Processing millions of records via standard Batch Apex can exceed heap limits (System.LimitException: Apex heap size too large) when calculating aggregate states or running memory-intensive transformations across chunks.
Solution: Architect stateful, dynamic Batch Apex implementations that implement Database.Stateful combined with custom iterator chunking and self-chaining execution patterns.
Code Snippet: Java
public class EnterpriseAccountAggregator implements Database.Batchable<SObject>, Database.Stateful {
public Decimal totalPortfolioValue = 0.0;
public Database.QueryLocator start(Database.BatchableContext bc) {
return Database.getQueryLocator([SELECT Id, AnnualRevenue FROM Account WHERE Processed__c = false]);
}
public void execute(Database.BatchableContext bc, List<Account> scope) {
for (Account acc : scope) {
if (acc.AnnualRevenue != null) {
totalPortfolioValue += acc.AnnualRevenue;
}
acc.Processed__c = true;
}
update scope;
}
public void finish(Database.BatchableContext bc) {
// Log state telemetry or chain downstream batch safely
System.debug(‘Total Portfolio Aggregated: ‘ + totalPortfolioValue);
}
}
3. Avoiding UNTYPED_FAILED & Handling Dynamic Payload Parsing
Challenge: Integration of Salesforce with third-party microservices generally leads to very dynamic or changing JSON schemas. Typed JSON deserialization will fail during runtime if unexpected fields or polymorphic schemas are received.
Solution: Use defensively typed JSON parsing along with dynamic map traversal patterns to extract the payload nodes without causing any runtime exception.
Code Snippet: Java
public class DynamicPayloadParser {
public static Decimal extractMetric(String jsonPayload, String targetKey) {
Map<String, Object> root = (Map<String, Object>) JSON.deserializeUntyped(jsonPayload);
if (root.containsKey(‘data’) && root.get(‘data’) instanceOf Map<String, Object>) {
Map<String, Object> dataNode = (Map<String, Object>) root.get(‘data’);
if (dataNode.containsKey(targetKey)) {
return Decimal.valueOf(String.valueOf(dataNode.get(targetKey)));
}
}
return 0.0;
}
}
4. Bypassing Governor Limits with Platform Event Bus Queuing
Challenge: Performing extensive post-processing (such as calculating metrics or updating other systems) within synchronous HTTP callouts or standard triggers results in CPU time-outs (LimitException: Apex CPU time limit exceeded).
Solution: Split the processing task in an asynchronous manner via Platform Events and have the process executed by the EventBus to reset the transaction governor limits.
Code Snippet: Java
public class EventDrivenPublisher {
public static void publishAuditLog(List<Id> recordIds) {
List<Order_Audit_Event__e> eventList = new List<Order_Audit_Event__e>();
for (Id rId : recordIds) {
eventList.add(new Order_Audit_Event__e(Record_ID__c = rId, Status__c = ‘Queued’));
}
// EventBus.publish runs in a decoupled execution context
List<Database.SaveResult> results = EventBus.publish(eventList);
}
}
5. Concurrent Row Locking (UNABLE_TO_LOCK_ROW) in Parallel Processing
Challenge: Whenever two or more Batch Apex jobs or integration calls try to update parent records (or junction objects), the transaction ends up failing due to the following error: System.QueryException: Record Currently Unavailable: UNABLE_TO_LOCK_ROW.
Solution: Utilize the FOR UPDATE clause in SOQL queries to explicitly lock target rows during critical sections, combined with catch-and-retry logic to handle lock collisions gracefully.
Code Snippet: Java
public class SecureRowLocker {
public static void updateAccountBalances(Set<Id> parentAccountIds, Decimal adjustment) {
// Explicitly lock target records to block concurrent thread collisions
List<Account> lockedAccounts = [SELECT Id, AnnualRevenue FROM Account
WHERE Id IN :parentAccountIds FOR UPDATE];
for (Account acc : lockedAccounts) {
acc.AnnualRevenue = (acc.AnnualRevenue != null ? acc.AnnualRevenue : 0) + adjustment;
}
update lockedAccounts;
}
}
Conclusion
Solving Salesforce complexities involves moving beyond the simple declarative approach to designing a more advanced programmatic solution architecture. Using the techniques of bulkification, governor limits management, event-based integration, and row locking, one can build highly scalable and secure applications that work well with large volumes of data.
Ready to master enterprise Salesforce development? Transform your career with our top-rated IT training institute in Chennai. Gain real-world experience in Apex, LWC, Integration, and Admin through expert mentorship, live projects, and dedicated placement support.