Salesforce

Describe how Salesforce’s multitenant, metadata-driven architecture affects application development.

Create a Salesforce Developer Edition org and locate core areas in Setup.

Differentiate Salesforce metadata, configuration, and business data using concrete examples.

Configure Visual Studio Code, Salesforce CLI, and the Salesforce Extension Pack.

Authorize a Salesforce org from the Salesforce CLI.

Create a Salesforce DX project with a standard source structure.

Retrieve selected metadata from an org into a local Salesforce DX project.

Deploy a metadata change from a local project to an org and verify the result.

Map a simple business requirement to standard and custom Salesforce objects.

Create a custom object with fields that use appropriate Salesforce data types.

Choose between lookup and master-detail relationships for a stated requirement.

Configure a lookup relationship between two objects.

Configure a master-detail relationship and a roll-up summary field.

Create a formula field that derives a value from related record data.

Create a validation rule with a user-friendly error message.

Load a small related dataset while preserving record relationships.

Configure a Lightning record page for a specific user workflow.

Use record types and page layouts to present different business processes.

Distinguish organization-, object-, field-, and record-level access controls.

Grant object and field access through a permission set.

Configure organization-wide defaults for a custom object.

Use role hierarchy and sharing rules to satisfy a record-access requirement.

Diagnose a user’s missing access with Salesforce access-inspection tools.

Verify a security configuration by testing it as users with different permissions.

Create a cross-object formula that implements a stated business rule.

Configure a duplicate rule and matching rule for a sample data-quality requirement.

Build a record-triggered Flow that updates a related record.

Add decisions and fault handling to a record-triggered Flow.

Build a screen Flow that creates a record from validated user input.

Debug a Flow with representative input data.

Identify where a declarative solution is preferable to Apex for a stated requirement.

Predict the relevant automation sequence for a record-save scenario.

Translate common Java constructs into their Apex equivalents and identify key differences.

Declare Apex variables and use conditional and looping control flow.

Manipulate lists, sets, and maps with Apex collection operations.

Read and modify fields on strongly typed and generic sObjects.

Define an Apex class with methods, properties, and access modifiers.

Apply inheritance or interfaces to a small Apex design.

Handle and report an Apex exception without hiding the underlying failure.

Trace an Apex execution using debug logs and checkpoints.

Write a selective SOQL query with filters, ordering, and limits.

Write parent-to-child and child-to-parent relationship queries.

Use bind variables safely in a static SOQL query.

Write an aggregate SOQL query and interpret its AggregateResult values.

Use SOSL to search text across multiple objects.

Perform insert, update, upsert, and delete operations with Apex DML.

Use Database methods to capture partial-success results.

Use a savepoint and rollback to control an Apex transaction.

Explain how governor limits follow from Salesforce’s multitenant execution model.

Measure relevant governor-limit consumption during an Apex transaction.

Refactor repeated SOQL queries out of a loop.

Refactor repeated DML operations into a bulk operation.

Use sets and maps to join related records without nested queries.

Apply with sharing, without sharing, or inherited sharing to a stated access requirement.

Enforce object- and field-level security in an Apex data operation.

Review an Apex method for injection, access-control, and data-exposure risks.

Select a before or after trigger context for a stated business rule.

Implement a bulk-safe trigger for insert and update events.

Use Trigger.new, Trigger.old, and their map variants appropriately.

Move trigger logic into a single-trigger handler structure.

Prevent unintended repeat processing without blocking valid bulk operations.

Coordinate a trigger with existing Flow automation to avoid conflicting updates.

Trace a record transaction through validation, automation, and commit behavior.

Refactor trigger logic into a reusable service-layer method.

Write an isolated Apex test method with deterministic assertions.

Create reusable test records with a test-data factory.

Use @testSetup to share baseline data across test methods.

Use Test.startTest and Test.stopTest to isolate limit consumption and asynchronous execution.

Test positive, negative, and bulk-processing scenarios for an Apex service.

Test trigger behavior under multiple record-operation contexts.

Diagnose an Apex failure from a stack trace and debug log.

Interpret code coverage while identifying behavior that remains untested.

Choose synchronous, Queueable, Batch, or Scheduled Apex for a stated workload.

Implement a Queueable Apex job and inspect its execution result.

Chain Queueable jobs while passing only safe state between jobs.

Implement Batch Apex with start, execute, and finish methods.

Write a test that executes one Batch Apex scope.

Schedule an Apex class with a cron expression.

Publish and subscribe to a platform event in a simple business workflow.

Design an idempotent asynchronous operation that tolerates retries.

Create and deploy a Lightning Web Component with its metadata configuration.

Render Salesforce data with template expressions and conditional directives.

Handle user input and DOM events in a Lightning Web Component.

Compose parent and child components using public properties and methods.

Send a custom event from a child component to its parent.

Read Salesforce data with Lightning Data Service or a wire adapter.

Create and edit records with base Lightning components.

Call an Apex method imperatively and display loading, success, and error states.

Configure a Named Credential for an authenticated external endpoint.

Implement an Apex REST callout and deserialize its JSON response.

Test an HTTP callout with an HttpCalloutMock implementation.

Expose a secured Apex REST endpoint for an external client.

Connect a small Spring Boot client to a Salesforce REST endpoint using OAuth.

Track Salesforce metadata changes in Git with a focused commit history.

Deploy the portfolio application to a separate org and run its Apex test suite.

Present the portfolio application’s architecture, security model, automation choices, and trade-offs in a concise technical walkthrough.