Salesforce Developer Interview questions 2025

Salesforce Developer Interview questions 2025

As Salesforce continues to evolve, the role of a Salesforce Developer demands expertise in Apex, Lightning Web Components (LWC), integrations, and performance optimization. In 2025, interviews will focus on scalability, security, and automation, ensuring developers can build robust and efficient applications. Mastery of SOQL tuning, governor limits, asynchronous processing, and AI-driven solutions is now essential. To succeed, candidates must showcase problem-solving skills, best coding practices, and hands-on experience with Salesforce DevOps and CI/CD pipelines.

1. What are the latest features introduced in Salesforce Winter ’25 release?

Salesforce Winter ’25 brings several enhancements across various cloud offerings. One of the key updates includes improved Einstein AI capabilities, making automation and analytics smarter. The Flow Builder has received new features that allow for better decision automation, along with enhancements in Dynamic Forms, which now support more objects. Additionally, Hyperforce Expansion improves data residency compliance, ensuring businesses can deploy Salesforce in more regions.

Another significant update is in Lightning Web Components (LWC), where performance improvements and new UI components enhance the user experience. The Apex Performance Profiler now provides deeper insights into code execution, making it easier to optimize. Salesforce has also introduced better API integrations, allowing developers to work with external systems more efficiently. The updates in Data Cloud enable businesses to unify and process large datasets faster, improving personalization and reporting capabilities.

2. How do you handle data masking in Salesforce for data security and compliance?

In Salesforce, data masking is essential for securing sensitive information and maintaining compliance with regulations like GDPR and CCPA. I use Salesforce Shield or Apex-based custom solutions to mask confidential data dynamically. With Shield’s Field Audit Trail, I ensure that data masking applies even when users access data via reports or exports. I also leverage Field-Level Security and Permission Sets to restrict access to sensitive information.

For custom implementations, I use Apex triggers to replace real data with masked values before saving it in lower environments. This prevents unauthorized access while allowing testing with realistic but anonymized data. Below is an example of an Apex trigger that masks credit card numbers:

trigger MaskCreditCard on Account (before insert, before update) {  
    for (Account acc : Trigger.new) {  
        if (acc.Credit_Card_Number__c != null) {  
            acc.Credit_Card_Number__c = 'XXXX-XXXX-XXXX-' + acc.Credit_Card_Number__c.right(4);  
        }  
    }  
}  

This trigger runs before insert or update and ensures that only the last four digits of the credit card number remain visible. It checks if the field contains a value before masking it. The .right(4) function extracts the last four digits, ensuring consistency. This method prevents unauthorized users from viewing sensitive card details.

3. Explain the use of Apex triggers for handling large-scale data operations.

I use Apex triggers when I need to automate processes at the database level, especially for large-scale data operations. When dealing with a high volume of records, I follow best practices to avoid governor limits. Instead of writing SOQL queries inside loops, I use bulkified triggers that handle thousands of records efficiently. Triggers are also useful for maintaining data consistency across related objects, ensuring that updates in one object reflect correctly in another.

To optimize performance, I use future methods and queueable Apex when triggers require external API calls or complex computations. For example, when updating millions of records, I use Batch Apex instead of processing all records within a single trigger execution. Below is a bulkified trigger that ensures opportunities are linked to the correct account:

trigger UpdateOpportunities on Account (after update) {  
    Map<Id, String> accountNames = new Map<Id, String>();  
    for (Account acc : Trigger.new) {  
        accountNames.put(acc.Id, acc.Name);  
    }  

    List<Opportunity> oppsToUpdate = [SELECT Id, AccountId FROM Opportunity WHERE AccountId IN :accountNames.keySet()];  
    for (Opportunity opp : oppsToUpdate) {  
        opp.Name = accountNames.get(opp.AccountId) + ' - Opportunity';  
    }  
    update oppsToUpdate;  
}  

This bulkified trigger collects account IDs and names in a Map to avoid multiple SOQL queries. It then retrieves all related opportunities in a single query. The trigger updates opportunity names in bulk, ensuring better performance and scalability. This approach prevents governor limit violations and enhances data consistency.

4. How do you optimize SOQL queries for better performance in large datasets?

Optimizing SOQL queries is crucial when dealing with large datasets in Salesforce. I always use SELECTive queries by filtering records with indexed fields such as Id, Name, CreatedDate, and External IDs. Instead of using **SELECT ***, I only query specific fields that are necessary for the operation. Using LIMIT and OFFSET where applicable further improves query performance, especially in pagination scenarios.

Another key optimization strategy is using SOQL for loops instead of traditional for loops to process records in manageable chunks. I also leverage Aggregate SOQL when working with large datasets to reduce the number of queried records. Below is an example of an optimized query that fetches high-value opportunities efficiently:

List<Opportunity> opps = [  
    SELECT Id, Name, Amount  
    FROM Opportunity  
    WHERE Amount > 100000  
    ORDER BY CloseDate DESC  
    LIMIT 50  
];  

This optimized SOQL query retrieves only the required fields, reducing memory usage. It filters opportunities where Amount > 100,000 to improve performance. The ORDER BY CloseDate DESC ensures recent opportunities appear first. The LIMIT 50 restricts query results, preventing unnecessary record retrieval.

5. What is Apex Governor Limits, and how do you ensure your code complies with them?

Salesforce enforces Apex Governor Limits to maintain platform stability and prevent a single tenant from consuming excessive resources. These limits include restrictions on CPU time, SOQL queries, DML statements, heap size, and concurrent transactions. I ensure compliance by writing bulkified code that processes records efficiently and minimizes resource usage.

One of my key strategies is avoiding SOQL and DML operations inside loops. Instead, I use collections (Lists, Sets, and Maps) to handle bulk processing efficiently. For example, if I need to update multiple accounts, I fetch all necessary records in a single SOQL query and update them in bulk:

List<Account> accList = [SELECT Id, Name FROM Account WHERE Industry = 'Technology'];  
for (Account acc : accList) {  
    acc.Name = acc.Name + ' - Updated';  
}  
update accList;  

This code ensures efficient bulk updates by retrieving all relevant accounts in a single SOQL query. The for loop updates the names in memory before performing a bulk DML update. This approach prevents hitting DML and SOQL governor limits. It also improves the execution speed and ensures compliance with Salesforce limits.

6. Can you describe the concept of Platform Events and their use cases in Salesforce?

Platform Events enable real-time event-driven communication within Salesforce and external systems. They work on the publish-subscribe model, where an event is published, and multiple subscribers can process it asynchronously. This makes them ideal for handling large-scale integrations, process automation, and system synchronization. Unlike triggers, platform events operate outside transactional boundaries, ensuring better scalability and reliability.

A common use case for platform events is integrating Salesforce with external systems like ERP or payment gateways. For example, when an order is placed, a platform event can notify an external warehouse system to initiate shipping. Below is an example of publishing a platform event in Apex:

Order_Event__e event = new Order_Event__e(Order_Id__c = '12345', Status__c = 'Shipped');  
EventBus.publish(event);  

This code creates an instance of the Order_Event__e platform event and publishes it using EventBus.publish(). The event carries order details, ensuring external systems receive real-time updates without direct API calls. This improves system decoupling and performance.

7. How would you implement data sharing rules programmatically in Salesforce?

I use Apex Managed Sharing to implement data sharing rules programmatically when standard sharing mechanisms like role hierarchy, OWD, and criteria-based sharing do not meet requirements. Manual sharing records are created in the Share object, which grants specific access to users or groups. This ensures flexibility in defining record-level permissions.

For example, if I need to grant Read access to an opportunity for a specific user, I create a record in the OpportunityShare object:

OpportunityShare oppShare = new OpportunityShare();  
oppShare.OpportunityId = '006xxxxxxxxxxxx';  
oppShare.UserOrGroupId = '005xxxxxxxxxxxx';  
oppShare.AccessLevel = 'Read';  
insert oppShare;  

This code creates a new OpportunityShare record with Read access for a user. The UserOrGroupId field specifies who gets access. Programmatic sharing is useful in custom security models, external integrations, and record ownership transfers where dynamic access control is required.

8. Explain the difference between @AuraEnabled and @wire in Lightning Web Components (LWC).

Both @AuraEnabled and @wire are used to fetch data in Lightning Web Components (LWC), but they serve different purposes. The @AuraEnabled annotation exposes Apex methods to JavaScript, allowing imperative calls to fetch or manipulate data. This approach is useful when dealing with complex logic, multiple operations, or conditional data retrieval.

On the other hand, @wire is a reactive mechanism that automatically fetches and refreshes data when dependencies change. It is best suited for reading Salesforce data efficiently. Below is a comparison of both approaches:

@AuraEnabled(cacheable=true)  
public static List<Account> getAccounts() {  
    return [SELECT Id, Name FROM Account LIMIT 10];  
}  

@wire(getAccounts) accounts;  

The @AuraEnabled(cacheable=true) method fetches Account records for LWC. The @wire decorator automatically retrieves and updates data without manual invocation, making it more efficient for real-time UI updates.

9. How would you design a solution for asynchronous processing in Salesforce?

For asynchronous processing, I use Future Methods, Queueable Apex, Batch Apex, and Platform Events, depending on the use case. If I need to execute a simple non-transactional process, I use @future methods. For chaining and job tracking, I prefer Queueable Apex. When handling millions of records, I implement Batch Apex for better scalability.

For example, to process large datasets asynchronously, I use Queueable Apex:

public class ProcessRecords implements Queueable {  
    public void execute(QueueableContext context) {  
        List<Account> accs = [SELECT Id, Name FROM Account];  
        for (Account acc : accs) {  
            acc.Name += ' - Processed';  
        }  
        update accs;  
    }  
}  

This Queueable Apex job retrieves all Account records, updates their names, and performs a bulk update. The job runs in the background, ensuring that Salesforce Governor Limits are not exceeded while processing large datasets.

10. Describe a scenario where you’d use the Bulk API in Salesforce.

I use Bulk API when processing large volumes of data, such as mass inserts, updates, and deletions. The Bulk API is ideal for data migrations, system integrations, and ETL processes. Unlike standard DML operations, Bulk API processes records asynchronously, improving performance and reducing API call consumption.

For example, if I need to import thousands of leads from an external system, I use the Bulk API to insert them efficiently. The following snippet demonstrates bulk insertion using the REST API:

{  
    "records": [  
        { "attributes": { "type": "Lead" }, "FirstName": "John", "LastName": "Doe", "Company": "ABC Inc." },  
        { "attributes": { "type": "Lead" }, "FirstName": "Jane", "LastName": "Smith", "Company": "XYZ Corp." }  
    ]  
}  

This JSON payload represents multiple Lead records for bulk insertion. The Bulk API processes these records asynchronously, ensuring faster execution without exceeding governor limits.

11. What are the new capabilities in LWC for enhancing user experience?

Salesforce continuously improves Lightning Web Components (LWC) to enhance user experience, performance, and developer productivity. One of the latest capabilities is Lightning Message Service (LMS), which allows communication between LWCs, Aura components, and Visualforce pages. This improves cross-component communication without using Apex. Another enhancement is Dynamic Interactions, enabling LWCs to send and receive data without custom event handling, making UI development more efficient.

Other notable enhancements include better caching with Lightning Data Service (LDS), improved event handling mechanisms, and declarative configuration of UI elements. Features like wire adapters for related records, record edit forms, and lightweight modals make LWC more user-friendly. These advancements help create responsive, high-performance UIs that integrate seamlessly with Salesforce’s ecosystem.

12. How do you secure sensitive data within Salesforce applications?

I follow best practices to secure sensitive data in Salesforce applications, ensuring compliance, data integrity, and privacy. The first step is leveraging Field-Level Security (FLS) and Object-Level Security (OLS) to restrict access based on user roles. Additionally, I use Platform Encryption to protect sensitive fields like Social Security Numbers or credit card details. Encrypted fields remain secure even in reports and search queries.

Another key practice is using Named Credentials to store API keys and credentials securely instead of hardcoding them in Apex. I also implement CRUD and FLS checks in Apex before performing DML operations to prevent unauthorized access.

For example:

if (Schema.sObjectType.Account.fields.SSN__c.isAccessible()) {  
    Account acc = [SELECT SSN__c FROM Account WHERE Id = :recordId];  
}  

This ensures that only users with the right permissions can access sensitive fields, reducing security risks. Additionally, I use Transaction Security Policies and Shield Event Monitoring to track and prevent unauthorized data access.

13. Explain the process for handling callouts in Apex with error handling.

In Salesforce, Apex callouts allow integration with external systems, but handling them requires proper error handling and exception management. Before making a callout, I define a Named Credential to manage authentication securely. I use HttpRequest and HttpResponse classes to interact with external services and ensure error handling with try-catch blocks.

For example, here’s a simple GET request with error handling:

Http http = new Http();  
HttpRequest request = new HttpRequest();  
request.setEndpoint('https://api.example.com/data');  
request.setMethod('GET');  
try {  
    HttpResponse response = http.send(request);  
    if (response.getStatusCode() == 200) {  
        System.debug('Success: ' + response.getBody());  
    } else {  
        System.debug('Error: ' + response.getStatusCode());  
    }  
} catch (Exception e) {  
    System.debug('Callout failed: ' + e.getMessage());  
}  

This code ensures that even if the external API fails, the error is logged without disrupting the Salesforce process. I also use Future Methods, Queueable Apex, or Continuation Class for handling long-running callouts in asynchronous processing.

14. Describe your approach to managing code deployments and CI/CD in Salesforce.

For code deployments and CI/CD in Salesforce, I follow a structured approach using version control, automated testing, and deployment pipelines. I use Git for version control, where all metadata changes are tracked, allowing easy rollbacks when needed. My CI/CD pipeline involves tools like Salesforce CLI, GitHub Actions, Jenkins, or Azure DevOps to automate deployments.

I configure scratch orgs or sandboxes for development and execute unit tests before deploying to higher environments. The deployment process typically follows:

Develop in a scratch org and push changes to the repository.
Run automated tests using Apex Test Runner to ensure quality.
Use SFDX or Metadata API to deploy changes to UAT or production.
Monitor logs and performance metrics post-deployment.

This structured approach ensures smooth, error-free deployments while maintaining compliance with Salesforce best practices.

15. How do you handle large data volumes in Salesforce when building custom solutions?

Handling large data volumes (LDV) in Salesforce requires efficient queries, indexing, and asynchronous processing. I optimize SOQL queries by using selective filters, indexed fields, and avoiding loops inside triggers. Instead of running queries inside a loop, I use bulkified queries to minimize Governor Limit violations.
For processing large records, I implement Batch Apex instead of synchronous execution. A sample Batch Apex implementation looks like this:

global class AccountBatchProcessor implements Database.Batchable<sObject> {  
    global Database.QueryLocator start(Database.BatchableContext bc) {  
        return Database.getQueryLocator('SELECT Id, Name FROM Account');  
    }  
    global void execute(Database.BatchableContext bc, List<Account> accList) {  
        for (Account acc : accList) {  
            acc.Name += ' - Processed';  
        }  
        update accList;  
    }  
    global void finish(Database.BatchableContext bc) {  
        System.debug('Batch Job Completed');  
    }  
}  

This Batch Apex job processes accounts efficiently by breaking the workload into smaller chunks. Additionally, I use Skinny Tables, Data Archiving, and External Objects to improve LDV performance, ensuring scalability and maintainability.

16. Can you discuss the use of Salesforce Connect for integrating external data?

In my experience, Salesforce Connect is a powerful tool for integrating external data without storing it in Salesforce. It allows us to connect to external systems like SAP, Oracle, or custom APIs using OData, Apex custom adapters, or cross-org adapters. This means I can work with external data as if it were native Salesforce data, without exceeding storage limits. The main benefit is real-time access to data while maintaining security and compliance.

To use Salesforce Connect, I define External Data Sources and create External Objects. Here’s an example of creating an OData connection:

<ExternalDataSource xmlns="http://soap.sforce.com/2006/04/metadata">  
    <FullName>My_External_Data</FullName>  
    <Label>External Data</Label>  
    <Type>OData</Type>  
    <Endpoint>https://myapi.com/odata</Endpoint>  
</ExternalDataSource>  

Once configured, I can query external objects using SOQL:

SELECT Name, External_Field__c FROM External_Object__x WHERE Status__c = 'Active'  

A key limitation I’ve faced is read-only access in some cases. To overcome this, I use custom Apex adapters for write-back operations. This allows me to integrate Salesforce with ERP systems, databases, and cloud storage while keeping data synchronized.

Code Explanation: The XML snippet defines an External Data Source in Salesforce that connects to an OData API. The SOQL query retrieves records from an external object as if it were a standard Salesforce object. This approach ensures that data is accessed in real-time without consuming Salesforce storage.

17. How would you handle a requirement for a multi-object report in Salesforce?

When I need a multi-object report, I first check if the Standard Report Types can meet the requirement. If they don’t, I create a Custom Report Type (CRT), which allows me to combine multiple related objects into a single report. For example, if I need a report that includes Accounts, Contacts, and Opportunities, I set up a Custom Report Type with the primary object as Account and add related objects.

For more complex scenarios, I use Joined Reports, which allow me to pull data from unrelated objects. This helps when I need to compare Cases vs. Opportunities or Leads vs. Campaigns in a single view. However, if objects don’t have direct relationships, I use Apex to create a reporting object and populate it with data:

List<Report_Data__c> reportDataList = new List<Report_Data__c>();  
for (Account acc : [SELECT Id, Name FROM Account]) {  
    Report_Data__c data = new Report_Data__c(Account_Name__c = acc.Name);  
    reportDataList.add(data);  
}  
insert reportDataList;  

This method allows me to preprocess data, ensuring that reports run faster and are optimized for business needs.

Code Explanation: This Apex snippet creates a custom reporting object and inserts data into it by iterating over Accounts. This method is useful when objects are unrelated and need to be combined for reporting purposes. The approach ensures that reports can include data from multiple objects efficiently.

18. Explain the use of Apex testing and best practices for high test coverage.

I always emphasize Apex testing because Salesforce enforces at least 75% code coverage before deployment. Apex tests allow me to validate logic, check governor limits, and prevent regressions. I follow best practices like creating test data using TestDataFactory, using Test.startTest() for limits, and covering both positive and negative test scenarios.

Here’s an example of an Apex test class for an Account trigger:

@isTest  
private class AccountTriggerTest {  
    @isTest  
    static void testAccountCreation() {  
        Test.startTest();  
        Account acc = new Account(Name='Test Account');  
        insert acc;  
        System.assertNotEquals(null, acc.Id, 'Account should be inserted');  
        Test.stopTest();  
    }  
}  

This test ensures that the Account trigger executes successfully. I also mock external callouts using HttpCalloutMock:

@isTest  
private class CalloutTest {  
    @isTest  
    static void testCallout() {  
        Test.setMock(HttpCalloutMock.class, new MyCalloutMock());  
        String response = MyServiceClass.makeCallout();  
        System.assertEquals('Success', response, 'Callout should return Success');  
    }  
}  

By following these practices, I ensure that my code remains reliable, scalable, and performs well in production.

Code Explanation: This test class ensures that an Account record is created successfully. Test.startTest() isolates governor limits, while System.assertNotEquals() checks that the Account insertion was successful. This approach ensures that the code runs reliably and meets Apex test coverage requirements.

19. Describe the use of Custom Metadata Types and their advantages.

I use Custom Metadata Types (CMTs) when I need to store configurable application settings that can be deployed easily across environments. Unlike Custom Settings, CMTs support SOQL queries and can be included in managed packages, making them perfect for storing API endpoints, feature toggles, and business rules.

One major advantage is that CMTs do not consume SOQL queries, making them efficient for frequently accessed settings. Here’s an example of how I retrieve Custom Metadata values in Apex:

Custom_Metadata__mdt config = Custom_Metadata__mdt.getInstance('Setting1');  
System.debug('Config Value: ' + config.Value__c);  

Another key benefit is that CMTs can be updated via Metadata API, meaning I don’t have to modify code when business rules change. Instead, I just update metadata records, making my applications more flexible and maintainable.

Code Explanation: This Apex snippet retrieves a Custom Metadata record by name and logs its value. Using Custom Metadata ensures that configurations are easy to update without modifying the code, making deployments more efficient.

20. How do you implement custom logging for debugging complex processes in Salesforce?

In my experience, custom logging is essential for debugging issues in production, especially when working with batch jobs, integrations, or asynchronous processing. Since System.debug() logs aren’t always accessible in production, I create a Custom Object (Log__c) to store log messages.

Here’s how I implement a Logging Utility Class:

public class Logger {  
    public static void log(String message, String level) {  
        Log__c log = new Log__c(Message__c = message, Level__c = level, CreatedDate__c = System.now());  
        insert log;  
    }  
}  

I use this in my Apex code like this:

Logger.log('Batch Job Started', 'INFO');  

This method ensures that all critical events are stored in a structured way, making troubleshooting easier. Additionally, I create batch jobs to delete old logs to prevent storage overflow.

Code Explanation: This class inserts log messages into a custom Log__c object to track important events. Using this approach ensures that errors and debug messages are recorded for troubleshooting without relying on System.debug().

21. What are some common patterns to avoid CPU time limits in Apex?

In my experience, CPU time limits can be avoided by optimizing loops, SOQL queries, and collections. I always ensure that I use bulk processing instead of running DML operations inside loops. Using maps and sets instead of multiple queries improves efficiency and reduces CPU time. I also break large processing tasks into Batch Apex or Queueable Apex to distribute execution over multiple transactions.
A key approach is using asynchronous processing for resource-intensive tasks:

public class AsyncJob implements Queueable {  
    public void execute(QueueableContext context) {  
        List<Account> accs = [SELECT Id, Name FROM Account LIMIT 10000];  
        for (Account acc : accs) {  
            acc.Name += ' Updated';  
        }  
        update accs;  
    }  
}  

Code Explanation: The above code uses Queueable Apex to process large amounts of data asynchronously. This prevents synchronous execution from hitting CPU limits by deferring work to the Salesforce queue, ensuring smooth operation.

22. How would you optimize data import processes for efficiency and accuracy?

When I optimize data import, I first ensure data cleansing to avoid duplicates and errors. I use External IDs to match records instead of relying on names or email fields. Also, I disable workflow rules, validation rules, and triggers during import to improve performance. Using Data Loader with Bulk API helps in handling large volumes efficiently.

For automation, I use Apex for bulk inserts to optimize DML operations:

List<Account> accList = new List<Account>();  
for (Integer i = 0; i < 5000; i++) {  
    accList.add(new Account(Name='Account ' + i));  
}  
insert accList;  

Code Explanation: This Apex snippet inserts 5000 records in a single DML operation instead of inserting them one by one. Using bulk DML operations reduces CPU time usage and ensures faster data processing without hitting governor limits.

23. Explain how you’d use Dynamic Forms in Salesforce for different user profiles.

I use Dynamic Forms to create flexible page layouts that change based on user profiles or field values. Instead of using multiple page layouts, I assign different field visibility rules to control what a user sees. This enhances user experience by displaying only relevant fields. For example, I configure a Dynamic Form on the Account page, where sales users see revenue fields, while support users see case-related fields.

For programmatic control, I use Lightning Data Service to dynamically render fields:

<lightning-record-form  
    record-id={recordId}  
    object-api-name="Account"  
    layout-type="Compact"  
    mode="edit">  
</lightning-record-form>  

Code Explanation: This Lightning Web Component (LWC) snippet dynamically renders an Account record form based on the user’s profile. It simplifies UI customization without requiring multiple record layouts, improving usability and performance.

24. Describe how to handle large file storage requirements in Salesforce.

When dealing with large file storage, I avoid storing files as Attachments or Documents since they consume Salesforce storage. Instead, I use Salesforce Files (ContentDocument) or integrate with external storage solutions like Amazon S3, Google Drive, or SharePoint. I also use Content Delivery Network (CDN) links for large files instead of storing them directly in Salesforce.

Here’s how I store and retrieve files using Apex and ContentDocument:

ContentVersion cv = new ContentVersion(  
    Title = 'Sample File',  
    PathOnClient = 'sample.pdf',  
    VersionData = Blob.valueOf('File content')  
);  
insert cv;  

Code Explanation: This snippet inserts a file into Salesforce Files using the ContentVersion object. Using Salesforce Files instead of Attachments ensures better scalability and supports external integrations for efficient storage management.

25. How do you troubleshoot and resolve issues with Salesforce integrations using REST API?

When troubleshooting REST API integrations, I first check API call logs in Debug Logs or Event Monitoring to see the request/response details. I also verify authentication settings like OAuth tokens, Connected Apps, and IP restrictions. If an integration fails, I check for HTTP status codes (e.g., 401 for unauthorized, 500 for server errors). Using Postman or Workbench, I manually test API calls before debugging Apex code.

Here’s how I log API responses in Apex for better debugging:

HttpRequest req = new HttpRequest();  
req.setEndpoint('https://api.example.com/data');  
req.setMethod('GET');  
HttpResponse res = new Http().send(req);  
System.debug('API Response: ' + res.getBody());  

Code Explanation: This Apex snippet makes a REST API call and logs the response using System.debug(). This helps diagnose API failures, authentication issues, or incorrect responses when troubleshooting Salesforce integrations.