Top 120 Salesforce Interview Questions Asked at Accenture 2026 | Apex, LWC, SOQL & Integration

// Encapsulation public class AccountService { private List<Account> accounts; public List<Account> getAccounts() { return accounts; } // controlled access } // Inheritance + Polymorphism public virtual class BaseTriggerHandler { public virtual void beforeInsert(List<SObject> newRecords) {} } public class AccountTriggerHandler extends BaseTriggerHandler { public override void beforeInsert(List<SObject> newRecords) { // Account-specific logic } } // Abstraction - Interface (Database.Batchable is itself an interface) public interface IProcessor { void process(List<SObject> records); } public class AccountProcessor implements IProcessor { public void process(List<SObject> records) { /* logic */ } }

public class AccountWrapper { @AuraEnabled public Account account { get; set; } @AuraEnabled public Boolean isSelected { get; set; } @AuraEnabled public Integer opportunityCount { get; set; } public AccountWrapper(Account acc, Integer oppCount) { this.account = acc; this.isSelected = false; this.opportunityCount = oppCount; } } @AuraEnabled(cacheable=true) public static List<AccountWrapper> getAccountsWithCount() { List<AccountWrapper> result = new List<AccountWrapper>(); for(Account a : [SELECT Id, Name, (SELECT Id FROM Opportunities) FROM Account LIMIT 100]) { result.add(new AccountWrapper(a, a.Opportunities.size())); } return result; }

// Define custom exception public class OrderValidationException extends Exception {} public class InsufficientInventoryException extends Exception {} // Use in service class public class OrderService { public static void createOrder(Order__c order) { if(order.Amount__c <= 0) { throw new OrderValidationException('Order amount must be greater than zero'); } Integer stock = getInventoryLevel(order.Product__c); if(stock < order.Quantity__c) { throw new InsufficientInventoryException( 'Only ' + stock + ' units available. Requested: ' + order.Quantity__c ); } insert order; } } // Caller can catch specifically try { OrderService.createOrder(order); } catch(InsufficientInventoryException e) { // Show inventory alert } catch(OrderValidationException e) { // Show validation error }

public class TaxCalculator { @InvocableMethod(label='Calculate Tax' description='Calculates GST for order amount' category='Order') public static List<Result> calculateTax(List<Request> requests) { List<Result> results = new List<Result>(); for(Request req : requests) { Result res = new Result(); res.taxAmount = req.orderAmount * 0.18; // 18% GST res.totalAmount = req.orderAmount + res.taxAmount; results.add(res); } return results; } public class Request { @InvocableVariable(required=true) public Decimal orderAmount; } public class Result { @InvocableVariable public Decimal taxAmount; @InvocableVariable public Decimal totalAmount; } }

@RestResource(urlMapping='/orders/*') global class OrderRestService { @HttpGet global static Order__c getOrder() { RestRequest req = RestContext.request; String orderId = req.requestURI.substring(req.requestURI.lastIndexOf('/') + 1); return [SELECT Id, Name, Amount__c, Status__c FROM Order__c WHERE Id = :orderId]; } @HttpPost global static String createOrder(String productName, Decimal amount) { Order__c order = new Order__c(Name = productName, Amount__c = amount, Status__c = 'New'); insert order; return order.Id; } @HttpDelete global static String cancelOrder() { RestRequest req = RestContext.request; String orderId = req.requestURI.substring(req.requestURI.lastIndexOf('/') + 1); Order__c order = [SELECT Id FROM Order__c WHERE Id = :orderId]; order.Status__c = 'Cancelled'; update order; return 'Order cancelled'; } } // URL: https://instance.salesforce.com/services/apexrest/orders/

public class NightlyCleanupScheduler implements Schedulable { public void execute(SchedulableContext ctx) { // Call a batch job for the actual work Database.executeBatch(new ExpiredRecordsBatch(), 200); } } // Schedule via Apex (one-time setup) String cronExp = '0 0 2 * * ?'; // Every day at 2:00 AM String jobName = 'Nightly Cleanup Job'; System.schedule(jobName, cronExp, new NightlyCleanupScheduler()); // OR schedule via Setup → Scheduled Jobs UI (no code needed)

public class AccountUtils { // Static - utility method, no state needed public static String formatAccountName(String name) { return name.trim().capitalize(); } // Instance - needs object state private List<Account> processedAccounts = new List<Account>(); public void processAccount(Account a) { a.Name = formatAccountName(a.Name); // Can call static methods processedAccounts.add(a); } public List<Account> getProcessed() { return processedAccounts; } } // Usage String name = AccountUtils.formatAccountName(' acme corp '); // Static - no new needed AccountUtils utils = new AccountUtils(); // Instance - needs new utils.processAccount(myAccount);

@isTest private class OrderServiceTest { @TestSetup static void setupData() { // Create data once for all tests in class Account acc = TestDataFactory.createAccount('Test Corp'); insert acc; } @isTest static void testCreateOrder_Success() { Account acc = [SELECT Id FROM Account LIMIT 1]; Test.startTest(); Order__c order = OrderService.createOrder(acc.Id, 5000); Test.stopTest(); System.assertNotEquals(null, order.Id, 'Order should be created'); System.assertEquals('New', order.Status__c, 'New order status should be New'); System.assertEquals(5000, order.Amount__c, 'Amount should match'); } @isTest static void testCreateOrder_NegativeAmount() { Account acc = [SELECT Id FROM Account LIMIT 1]; Test.startTest(); try { OrderService.createOrder(acc.Id, -100); System.assert(false, 'Should have thrown OrderValidationException'); } catch(OrderValidationException e) { System.assert(e.getMessage().contains('greater than zero'), 'Error message mismatch'); } Test.stopTest(); } }

// Debug levels in practice System.debug(LoggingLevel.ERROR, 'Critical: Order failed for ID: ' + orderId); System.debug(LoggingLevel.INFO, 'Processing ' + records.size() + ' records'); System.debug(LoggingLevel.FINE, 'Entering calculateTax method'); // Production pattern - conditional debug if(Test.isRunningTest()) { System.debug('Test mode: ' + variable); } // Better: use a configurable logger class Logger.log('Order created: ' + orderId, LoggingLevel.INFO);

// SOQL - precise, one object List<Account> accs = [SELECT Id, Name FROM Account WHERE Industry = 'Technology' AND AnnualRevenue > 1000000]; // SOSL - cross-object text search List<List<SObject>> results = [FIND 'Accenture*' IN ALL FIELDS RETURNING Account(Id, Name), Contact(Id, Name, Email), Lead(Id, Name)]; List<Account> accounts = (List<Account>) results[0]; List<Contact> contacts = (List<Contact>) results[1]; // One search found Accenture in Accounts AND Contacts simultaneously

// Child-to-Parent: dot notation on relationship field List<Contact> contacts = [ SELECT Id, Name, Account.Name, Account.Industry, Account.Owner.Name FROM Contact WHERE Account.Industry = 'Technology' ]; // Parent-to-Child: subquery using child relationship name List<Account> accounts = [ SELECT Id, Name, (SELECT Id, Name, Email FROM Contacts WHERE IsActive__c = true ORDER BY Name), (SELECT Id, Amount, StageName FROM Opportunities WHERE IsClosed = false) FROM Account WHERE Type = 'Customer' ]; // Access subquery results for(Account acc : accounts) { System.debug('Account: ' + acc.Name + ' has ' + acc.Contacts.size() + ' contacts'); for(Contact c : acc.Contacts) { System.debug(c.Name); } } // Custom relationship names: remove __c → add __r // Order__c → Order__r (child-to-parent) // Order_Line_Items__r (parent-to-child, pluralized)

// VULNERABLE - injection possible String name = ApexPages.currentPage().getParameters().get('name'); // Attacker enters: ' OR Name != ' → query becomes: WHERE Name = '' OR Name != '' String q = 'SELECT Id FROM Account WHERE Name = \'' + name + '\''; // SAFE - bind variable (best approach) String q = 'SELECT Id FROM Account WHERE Name = :name'; // name bound safely List<Account> accs = Database.query(q); // SAFE - escaped (for dynamic field/object names) String safeName = String.escapeSingleQuotes(name); String q2 = 'SELECT Id FROM Account WHERE Name = \'' + safeName + '\'';

// Aggregate functions with GROUP BY and HAVING AggregateResult[] results = [ SELECT StageName, COUNT(Id) oppCount, SUM(Amount) totalValue, AVG(Amount) avgValue, MAX(Amount) maxDeal FROM Opportunity WHERE CloseDate = THIS_FISCAL_YEAR AND IsClosed = false GROUP BY StageName HAVING SUM(Amount) > 500000 // Only stages with >500K pipeline ORDER BY SUM(Amount) DESC ]; for(AggregateResult ar : results) { System.debug( 'Stage: ' + ar.get('StageName') + ' | Count: ' + ar.get('oppCount') + ' | Total: £' + ar.get('totalValue') ); }

// Five practical examples // 1. Leads created in last 30 days List<Lead> recentLeads = [SELECT Id FROM Lead WHERE CreatedDate = LAST_N_DAYS:30]; // 2. Open opportunities closing this quarter List<Opportunity> thisQtr = [SELECT Id FROM Opportunity WHERE CloseDate = THIS_FISCAL_QUARTER AND IsClosed = false]; // 3. Cases not updated in last 7 days (overdue) List<Case> overdue = [SELECT Id FROM Case WHERE LastModifiedDate < LAST_N_DAYS:7 AND Status != 'Closed']; // 4. Accounts created this month List<Account> newAccs = [SELECT Id FROM Account WHERE CreatedDate = THIS_MONTH]; // 5. Tasks due in next 5 days List<Task> upcoming = [SELECT Id FROM Task WHERE ActivityDate = NEXT_N_DAYS:5 AND Status != 'Completed'];

// Inventory deduction - concurrent transactions could both read same stock level // WITHOUT FOR UPDATE: two transactions both read stock=10, both deduct 8, both succeed but stock goes negative // WITH FOR UPDATE: second transaction waits until first completes List<Inventory__c> inv = [SELECT Id, Stock__c FROM Inventory__c WHERE Product__c = :productId FOR UPDATE]; // Record locked - only this transaction can modify it if(inv[0].Stock__c >= requestedQty) { inv[0].Stock__c -= requestedQty; update inv[0]; } else { throw new InsufficientInventoryException('Insufficient stock'); } // Lock released after DML

global class AccountBatch implements Database.Batchable<SObject> { global Database.QueryLocator start(Database.BatchableContext bc) { // QueryLocator: server-side cursor, 50M record capacity return Database.getQueryLocator('SELECT Id, Rating FROM Account WHERE Rating = null'); // vs Database.query(): would fail with heap limit at ~50K records } global void execute(Database.BatchableContext bc, List<Account> scope) { // scope = 200 records (or your batch size) // Fresh governor limits per execute() call for(Account a : scope) a.Rating = 'Cold'; update scope; } global void finish(Database.BatchableContext bc) {} }

// Dynamic query utility - object and filter are runtime decisions public static List<SObject> searchRecords(String objectName, Map<String, String> filters) { String query = 'SELECT Id, Name FROM ' + String.escapeSingleQuotes(objectName); if(!filters.isEmpty()) { List<String> conditions = new List<String>(); for(String field : filters.keySet()) { String val = filters.get(field); // Use bind approach for values conditions.add(String.escapeSingleQuotes(field) + ' = \'' + String.escapeSingleQuotes(val) + '\''); } query += ' WHERE ' + String.join(conditions, ' AND '); } return Database.query(query); } // Called for Account: searchRecords('Account', new Map<String,String>{'Industry'=>'Tech'}) // Called for Lead: searchRecords('Lead', new Map<String,String>{'Status'=>'Open'})

import { LightningElement, track } from 'lwc'; export default class MyComp extends LightningElement { @track counter = 0; isInitialized = false; constructor() { super(); } // Fires ONCE — no DOM access here connectedCallback() { // Fires ONCE — safe for data loading this.loadInitialData(); } renderedCallback() { // Fires EVERY RENDER — guard with boolean! if(this.isInitialized) return; this.isInitialized = true; // Safe to access DOM elements — they exist after first render const canvas = this.template.querySelector('canvas'); if(canvas) this.initializeChart(canvas); } incrementCounter() { this.counter++; // Triggers re-render → renderedCallback fires again // Without isInitialized guard, initializeChart() would fire every click! } }

import { LightningElement, api, track, wire } from 'lwc'; import getAccounts from '@salesforce/apex/AccountController.getAccounts'; export default class AccountDashboard extends LightningElement { @api recordId; // PUBLIC — parent passes this value in HTML @api get title() { // PUBLIC getter with logic return this._title || 'Accounts'; } set title(val) { this._title = val.toUpperCase(); } @track filters = { // REACTIVE — deep mutations tracked (arrays/objects) industry: '', type: '' }; @wire(getAccounts, { // REACTIVE WIRE — re-fires when recordId changes accId: '$recordId', // $ prefix = reactive parameter industry: '$filters.industry' }) wiredAccounts({ data, error }) { if(data) this.accounts = data; if(error) this.errorMsg = error.body.message; } }

// CHILD COMPONENT (productCard.js) import { LightningElement, api } from 'lwc'; export default class ProductCard extends LightningElement { @api product; // Receives data FROM parent via @api handleAddToCart() { // Sends data TO parent via CustomEvent this.dispatchEvent(new CustomEvent('addtocart', { detail: { productId: this.product.Id, quantity: this.quantity }, bubbles: true, // Event propagates up DOM tree composed: true // Event crosses Shadow DOM boundaries })); } } // PARENT HTML // <c-product-card product={selectedProduct} onaddtocart={handleAddToCart}></c-product-card> // PARENT JS handleAddToCart(event) { const { productId, quantity } = event.detail; this.cartItems.push({ productId, quantity }); this.updateCartTotal(); } // SIBLING: use Lightning Message Service (LMS) for unrelated components

// Message Channel: force-app/main/default/messageChannels/ProductSelected.messageChannel-meta.xml // PUBLISHER (product list component) import { publish, MessageContext } from 'lightning/messageService'; import PRODUCT_SELECTED from '@salesforce/messageChannel/ProductSelected__c'; export default class ProductList extends LightningElement { @wire(MessageContext) messageContext; selectProduct(productId) { publish(this.messageContext, PRODUCT_SELECTED, { productId, timestamp: Date.now() }); } } // SUBSCRIBER (product detail component — completely separate, no parent/child relationship) import { subscribe, unsubscribe, MessageContext } from 'lightning/messageService'; export default class ProductDetail extends LightningElement { @wire(MessageContext) messageContext; subscription = null; connectedCallback() { this.subscription = subscribe(this.messageContext, PRODUCT_SELECTED, (msg) => { this.loadProduct(msg.productId); }); } disconnectedCallback() { unsubscribe(this.subscription); // Prevent memory leaks this.subscription = null; } }

/* Parent CSS */ .card { background: red; font-size: 18px; } /* This DOES NOT affect child component's .card elements — Shadow DOM blocks it */ /* To style across shadow boundary — CSS custom properties */ /* Parent CSS */ :host { --card-bg: blue; --card-padding: 16px; } /* Child CSS — reads parent's custom property */ .card { background: var(--card-bg, white); padding: var(--card-padding, 8px); } /* :host selector — styles the component's root element from within */ :host { display: block; margin: 16px 0; } :host([variant="large"]) { font-size: 18px; } /* Conditional host styling */

import { LightningElement, wire } from 'lwc'; import getAccounts from '@salesforce/apex/AccountController.getAccounts'; import saveAccount from '@salesforce/apex/AccountController.saveAccount'; import { ShowToastEvent } from 'lightning/platformShowToastEvent'; import { refreshApex } from '@salesforce/apex'; export default class AccountManager extends LightningElement { wiredAccountsResult; // Store wire result for refreshApex // @wire: AUTO-CALLS on component load, reactive to parameter changes @wire(getAccounts, { type: 'Customer' }) wiredAccounts(result) { this.wiredAccountsResult = result; if(result.data) this.accounts = result.data; } // IMPERATIVE: user-triggered, full control async handleSave() { this.isLoading = true; try { await saveAccount({ accountData: this.formData }); this.dispatchEvent(new ShowToastEvent({ title: 'Saved!', variant: 'success' })); refreshApex(this.wiredAccountsResult); // Refresh wire after save } catch(error) { this.dispatchEvent(new ShowToastEvent({ title: 'Error', message: error.body.message, variant: 'error' })); } finally { this.isLoading = false; } } }

import { LightningElement } from 'lwc'; import { NavigationMixin } from 'lightning/navigation'; export default class NavigationDemo extends NavigationMixin(LightningElement) { // Navigate to a specific record page viewRecord(recordId) { this[NavigationMixin.Navigate]({ type: 'standard__recordPage', attributes: { recordId: recordId, actionName: 'view' } }); } // Navigate to object list view viewAllAccounts() { this[NavigationMixin.Navigate]({ type: 'standard__objectPage', attributes: { objectApiName: 'Account', actionName: 'list' } }); } // Navigate to external URL openSFInterviewPro() { this[NavigationMixin.Navigate]({ type: 'standard__webPage', attributes: { url: 'https://www.sfinterviewpro.com' } }); } // Get URL without navigating (for href attributes) async getRecordUrl(recordId) { const url = await this[NavigationMixin.GenerateUrl]({ type: 'standard__recordPage', attributes: { recordId: recordId, actionName: 'view' } }); return url; } }

import { LightningElement, wire } from 'lwc'; import getOpportunities from '@salesforce/apex/OppController.getOpportunities'; export default class OpportunityList extends LightningElement { @wire(getOpportunities) opps; // Getters — computed properties, auto-reactive, testable get hasData() { return this.opps?.data?.length > 0; // Optional chaining prevents null errors } get totalValue() { if(!this.opps?.data) return '£0'; const total = this.opps.data.reduce((sum, opp) => sum + (opp.Amount || 0), 0); return '£' + total.toLocaleString(); } get sortedByAmount() { return this.opps?.data ? [...this.opps.data].sort((a,b) => b.Amount - a.Amount) : []; } get isLoading() { return !this.opps; } get hasError() { return !!this.opps?.error; } get errorMessage() { return this.opps?.error?.body?.message; } } // Template: <template if:true={hasData}> // <p>Total: {totalValue}</p> // <template for:each={sortedByAmount} for:item="opp">

import { LightningElement } from 'lwc'; import { ShowToastEvent } from 'lightning/platformShowToastEvent'; import saveData from '@salesforce/apex/DataService.saveData'; export default class ErrorHandlingDemo extends LightningElement { errorMessage; // Helper to extract meaningful error message getErrorMessage(error) { if(Array.isArray(error.body)) { return error.body.map(e => e.message).join('\n'); } if(typeof error.body?.message === 'string') { return error.body.message; } if(error.body?.output?.errors) { return error.body.output.errors.map(e => e.message).join('\n'); } return 'Unknown error occurred'; } async handleSave() { try { await saveData({ data: this.formData }); this.dispatchEvent(new ShowToastEvent({ title: 'Success', message: 'Record saved!', variant: 'success' })); this.errorMessage = null; } catch(error) { this.errorMessage = this.getErrorMessage(error); this.dispatchEvent(new ShowToastEvent({ title: 'Save Failed', message: this.errorMessage, variant: 'error', mode: 'sticky' })); } } }

// Component HTML // <lightning-datatable key-field="Id" data={opportunities} columns={columns} // sorted-by={sortedBy} sorted-direction={sortedDirection} // onsort={handleSort} onrowaction={handleAction} // enable-infinite-loading onloadmore={loadMore}></lightning-datatable> // JavaScript columns = [ { label: 'Name', fieldName: 'Name', type: 'url', typeAttributes: { label: { fieldName: 'Name' }, target: '_blank' }, sortable: true }, { label: 'Amount', fieldName: 'Amount', type: 'currency', sortable: true }, { label: 'Stage', fieldName: 'StageName', type: 'text', sortable: true }, { label: 'Close Date', fieldName: 'CloseDate', type: 'date-local', sortable: true }, { type: 'action', typeAttributes: { rowActions: this.getRowActions() } } ]; getRowActions() { return [{ label: 'View', name: 'view' }, { label: 'Edit', name: 'edit' }]; } handleAction(event) { const { action, row } = event.detail; if(action.name === 'view') this.navigateToRecord(row.Id); }

import { LightningElement, wire, api } from 'lwc'; import { getRecord, getFieldValue } from 'lightning/uiRecordApi'; // Schema imports - validated at compile time import ACCOUNT_NAME from '@salesforce/schema/Account.Name'; import ACCOUNT_INDUSTRY from '@salesforce/schema/Account.Industry'; import ACCOUNT_REVENUE from '@salesforce/schema/Account.AnnualRevenue'; import ACCOUNT_OBJECT from '@salesforce/schema/Account'; export default class AccountDetail extends LightningElement { @api recordId; @wire(getRecord, { recordId: '$recordId', fields: [ACCOUNT_NAME, ACCOUNT_INDUSTRY, ACCOUNT_REVENUE] }) account; get name() { return getFieldValue(this.account.data, ACCOUNT_NAME); } get industry() { return getFieldValue(this.account.data, ACCOUNT_INDUSTRY); } } // If Account.Name is renamed in org → compilation fails immediately // vs hardcoded 'Account.Name' string → fails at runtime when user loads component

<!-- lightning-record-edit-form - zero Apex, respects FLS and validation rules --> <lightning-record-edit-form record-id={recordId} object-api-name="Opportunity" onsuccess={handleSuccess} onerror={handleError} onsubmit={handleSubmit}> <lightning-messages></lightning-messages> <!-- shows form-level errors --> <lightning-input-field field-name="Name"></lightning-input-field> <lightning-input-field field-name="Amount"></lightning-input-field> <lightning-input-field field-name="StageName"></lightning-input-field> <lightning-input-field field-name="CloseDate"></lightning-input-field> <lightning-button type="submit" label="Save"></lightning-button> </lightning-record-edit-form> // onsuccess: fires with created/updated record // onerror: fires with validation/server errors // onsubmit: fires before submission — intercept to modify fields

import { LightningElement } from 'lwc'; import { loadScript, loadStyle } from 'lightning/platformResourceLoader'; import CHART_JS from '@salesforce/resourceUrl/ChartJS'; // Static Resource export default class ChartComponent extends LightningElement { chartInitialized = false; renderedCallback() { if(this.chartInitialized) return; this.chartInitialized = true; Promise.all([ loadScript(this, CHART_JS + '/Chart.min.js'), loadStyle(this, CHART_JS + '/Chart.min.css') ]) .then(() => { this.initializeChart(); }) .catch(error => { console.error('Failed to load Chart.js:', error); }); } initializeChart() { const ctx = this.template.querySelector('canvas').getContext('2d'); new window.Chart(ctx, { type: 'bar', data: this.chartData, options: { responsive: true } }); } }

// WITHOUT Named Credentials - SECURITY RISK HttpRequest req = new HttpRequest(); req.setEndpoint('https://api.erp.com/orders'); req.setHeader('Authorization', 'Bearer hardcoded_token_here'); // In GitHub = security breach! // WITH Named Credentials - SECURE HttpRequest req = new HttpRequest(); req.setEndpoint('callout:ERP_Integration/orders'); req.setMethod('GET'); // No credentials in code. Salesforce resolves authentication automatically. // Token refresh handled automatically for OAuth credentials.

// WRONG - Callout in trigger trigger OrderTrigger on Order__c (after insert) { for(Order__c o : Trigger.new) { Http h = new Http(); // ERROR: Uncommitted work pending } } // CORRECT - Delegate to @future trigger OrderTrigger on Order__c (after insert) { List<Id> orderIds = new List<Id>(Trigger.newMap.keySet()); ERPService.syncOrders(orderIds); // Calls @future method } public class ERPService { @future(callout=true) public static void syncOrders(List<Id> orderIds) { List<Order__c> orders = [SELECT Id, Name, Amount__c FROM Order__c WHERE Id IN :orderIds]; // Make HTTP callout here safely HttpRequest req = new HttpRequest(); req.setEndpoint('callout:ERP_System/orders'); req.setMethod('POST'); req.setBody(JSON.serialize(orders)); new Http().send(req); } }

// Task WhoId is polymorphic - can be Contact or Lead Task t = [SELECT Id, WhoId, Who.Name, Who.Type FROM Task LIMIT 1]; // Who.Type = 'Contact' or 'Lead' depending on the record // SOQL for polymorphic fields: List<Task> tasks = [SELECT Id, WhoId, Who.Name, TYPEOF Who WHEN Contact THEN Phone, Email WHEN Lead THEN Company, Status END FROM Task WHERE WhoId != null];

// Root cause: nested loop in execute() = O(n²) complexity // BAD for(Account a : scope) { for(Contact c : allContacts) { // Scans all contacts per account if(c.AccountId == a.Id) { /* process */ } } } // FIX: Map for O(1) lookup instead of O(n) scan Map<Id, List<Contact>> contactMap = /* pre-built in start() or early in execute() */; for(Account a : scope) { List<Contact> contacts = contactMap.get(a.Id); // O(1) lookup } // Also reduced batch size: Database.executeBatch(new MyBatch(), 50);

// LWC JS - auto-refreshing stock price import { LightningElement, api, wire } from 'lwc'; import getStockPrice from '@salesforce/apex/StockService.getStockPrice'; export default class StockPriceWidget extends LightningElement { @api stockSymbol; price; error; isLoading; refreshInterval; connectedCallback() { this.fetchPrice(); this.refreshInterval = setInterval(() => this.fetchPrice(), 30000); // Every 30s } disconnectedCallback() { clearInterval(this.refreshInterval); // Clean up! } async fetchPrice() { this.isLoading = true; try { this.price = await getStockPrice({ symbol: this.stockSymbol }); this.error = null; } catch(e) { this.error = e.body.message; } finally { this.isLoading = false; } } }