Quick answers to key questions

Short answers to the questions above. Add an example from your own project when you answer in an interview.

Apex, SOQL and triggers

• Parent-to-child and child-to-parent queries. A parent-to-child query uses a subquery on the child relationship name, for example SELECT Id, Name, (SELECT Id, LastName FROM Contacts) FROM Account. A child-to-parent query uses dot notation, for example SELECT Id, LastName, Account.Name FROM Contact.
• Profile and Permission Set. A profile is the base set of permissions and every user has exactly one. A permission set adds extra access on top of the profile, and a user can have many. Permission sets can only grant access, never remove it, so the usual approach is a minimal profile plus permission sets.
• Async and await. These are JavaScript keywords used in LWC, not Apex. An async function always returns a promise, and await pauses the function until the promise is resolved. They are commonly used to call Apex methods imperatively.

Trigger: create Contacts based on a number field

The trigger runs after insert and after update on Account. It compares the new and old values of the number field, creates the missing Contacts when the number goes up, and deletes the extra Contacts when it goes down. The API name Number_of_Contacts__c is assumed here, so change it to match your field.

trigger AccountContactTrigger on Account (after insert, after update) {
    List<Contact> toInsert = new List<Contact>();
    Map<Id, Integer> toDelete = new Map<Id, Integer>();

    for (Account acc : Trigger.new) {
        Integer newCount = acc.Number_of_Contacts__c == null ? 0 : acc.Number_of_Contacts__c.intValue();
        Integer oldCount = 0;
        if (Trigger.isUpdate) {
            Decimal oldVal = Trigger.oldMap.get(acc.Id).Number_of_Contacts__c;
            oldCount = oldVal == null ? 0 : oldVal.intValue();
        }
        if (newCount > oldCount) {
            for (Integer i = 0; i < newCount - oldCount; i++) {
                toInsert.add(new Contact(LastName = acc.Name + ' Contact', AccountId = acc.Id));
            }
        } else if (newCount < oldCount) {
            toDelete.put(acc.Id, oldCount - newCount);
        }
    }

    insert toInsert;

    if (!toDelete.isEmpty()) {
        List<Contact> deleteList = new List<Contact>();
        Map<Id, Integer> remaining = new Map<Id, Integer>(toDelete);
        for (Contact c : [SELECT Id, AccountId FROM Contact
                          WHERE AccountId IN :toDelete.keySet()
                          ORDER BY CreatedDate DESC]) {
            Integer left = remaining.get(c.AccountId);
            if (left > 0) {
                deleteList.add(c);
                remaining.put(c.AccountId, left - 1);
            }
        }
        delete deleteList;
    }
}

Invocable method example

public with sharing class AccountInvocable {
    @InvocableMethod(label='Get Account Names' description='Returns the name of each Account Id')
    public static List<String> getAccountNames(List<Id> accountIds) {
        List<String> names = new List<String>();
        for (Account a : [SELECT Name FROM Account WHERE Id IN :accountIds]) {
            names.add(a.Name);
        }
        return names;
    }
}

An invocable method must be static, can take only one input parameter (usually a list), and can be called from a flow, which is why it is a popular way to run Apex from a flow.

LWC and Flows

• Before-save flows. Yes. A record-triggered flow can run before the record is saved. It updates fields on the same record without a DML statement, so it is very fast.
• Wire and imperative. A wired method is reactive. The platform calls Apex or the data service for you and calls it again when a reactive parameter changes, and the Apex method needs cacheable=true. An imperative call happens when you decide, for example on a button click, and it returns a promise. Use imperative calls for DML or when you need full control.
• Calling a flow from an LWC. You can launch a screen flow inside an LWC with the lightning-flow component. An autolaunched flow can be started from Apex.
• Calling an LWC from a flow. Yes. A custom LWC can be used as a screen component in a screen flow when it is exposed with the lightning__FlowScreen target.
• Can we bypass a flow during Data Loader or Data Import Wizard loads? Not automatically. Record-triggered flows run on any save, including data loads. To bypass a flow, add an entry condition that checks a custom permission, a custom setting or a custom metadata flag.
• LWC lifecycle. The main hooks in order are constructor, connectedCallback, render, renderedCallback and disconnectedCallback. errorCallback catches errors from child components.
• Scheduled path and scheduled-triggered flow. A scheduled path is part of a record-triggered flow and runs at a time relative to a record event, for example 3 days after the Close Date. A scheduled-triggered flow runs at a set time and frequency on all records that match its filters and is not tied to a record change.
• Types of flows. The main types are Screen, Record-Triggered, Schedule-Triggered, Platform Event-Triggered and Autolaunched flows, plus Flow Orchestrator for multi-step processes. Salesforce adds features every release, so check the release notes for the latest.