Switching Companies

Implement an Apex class using typed methods, constructors, access modifiers, and interfaces.

Use lists, sets, and maps to transform collections of Salesforce records efficiently.

Write SOQL queries that use relationship queries, aggregate functions, bind variables, and selective filters.

Perform bulk DML with partial-success handling by using Database methods and SaveResult objects.

Implement structured exception handling that preserves useful diagnostic information.

Construct dynamic SOQL safely while preventing SOQL injection.

Refactor an inefficient Apex transaction to reduce SOQL, DML, CPU-time, and heap consumption.

Choose between record-triggered Flow, scheduled Flow, approval processes, and Apex for a given automation requirement.

Build a record-triggered Flow that handles entry criteria, related records, and fault paths.

Apply trigger context variables correctly across before, after, insert, update, delete, and undelete events.

Implement a one-trigger-per-object handler pattern with separated business logic.

Bulkify trigger logic for transactions containing up to 200 records.

Prevent unwanted trigger re-entry using idempotent logic and transaction-scoped state.

Diagnose an automation defect caused by interactions among Flow, validation rules, and Apex triggers.

Select Future, Queueable, Batch, or Scheduled Apex based on workload, limits, monitoring, and chaining requirements.

Implement a Queueable Apex job that performs a callout and chains follow-up work safely.

Implement Batch Apex with appropriate query, execute, state, and finish behavior.

Schedule and monitor recurring Apex work using the schedulable interface and platform tooling.

Publish and consume a Platform Event with an Apex or Flow subscriber.

Use Change Data Capture to propagate Salesforce record changes to an external consumer.

Design retry, idempotency, and failure-monitoring behavior for asynchronous processing.

Build an LWC using HTML templates, JavaScript modules, metadata configuration, and reactive properties.

Implement parent-to-child communication with public properties and methods.

Implement child-to-parent and unrelated-component communication using custom events and Lightning Message Service.

Read and update Salesforce records with Lightning Data Service and UI API wire adapters.

Call cacheable and non-cacheable Apex methods from an LWC using wired and imperative patterns.

Implement accessible forms with client-side validation, server-error handling, and user feedback.

Apply LWC lifecycle hooks, navigation, and conditional rendering without introducing avoidable rerenders.

Choose among request-reply, fire-and-forget, batch synchronization, data virtualization, and event-driven integration patterns.

Configure a Named Credential and select an appropriate OAuth flow for an outbound integration.

Implement an Apex REST endpoint with request validation, status codes, and a stable response contract.

Implement an authenticated Apex REST callout to an external service.

Serialize and deserialize typed and untyped JSON payloads in Apex.

Make an external operation safe to retry by applying idempotency keys and duplicate detection.

Test an HTTP integration deterministically with HttpCalloutMock for success and failure responses.

Enforce record sharing, object permissions, and field permissions in Apex using current platform security mechanisms.

Identify and remediate CRUD, field-level security, sharing, injection, and sensitive-data exposure risks in a code sample.

Optimize SOQL for large data volumes using selectivity, indexes, query plans, and pagination.

Design an archival strategy that controls Salesforce data growth while preserving required access.

Select caching techniques for server-side Apex, Lightning Data Service, and frequently reused reference data.

Estimate transaction and API-limit pressure from stated user volumes and integration traffic.

Evaluate synchronous, asynchronous, and event-driven designs against scalability, consistency, and failure-isolation requirements.

Write an Apex unit test with explicit setup, execution, assertions, and negative cases.

Build reusable test-data factories without relying on organization data.

Test trigger, Queueable, Batch, scheduled, and Platform Event behavior using the correct test execution boundaries.

Isolate Apex dependencies with stubs, fakes, or interfaces when direct integration would make tests unreliable.

Evaluate test quality using behavioral assertions rather than code coverage alone.

Use a Git feature-branch workflow to review and merge Salesforce metadata changes.

Design a CI/CD pipeline that validates metadata, runs tests, promotes releases, and supports rollback.

Map a telecommunications customer lifecycle across acquisition, order capture, activation, billing, service, and retention.

Model consumer and business subscribers, contacts, service accounts, products, assets, and service locations in Salesforce.

Identify system-of-record boundaries among Salesforce, product catalog, order management, billing, provisioning, and network systems.

Translate a TMT business requirement into user stories with testable acceptance criteria.

Design an event-driven order-status flow across CRM, fulfillment, billing, and customer-notification systems.

Design a Salesforce service process for omnichannel cases, entitlements, escalations, and outage communications.

Apply consent, privacy, audit, and least-privilege requirements to a TMT customer-data scenario.

Analyze the time and space complexity of an Apex solution.

Solve an array or list problem in Apex using a single-pass technique.

Solve a deduplication or frequency-counting problem using sets and maps.

Solve a string-processing problem while handling null, whitespace, and case requirements.

Implement binary search and explain when its sorted-input requirement is justified.

Use a stack or queue to solve an ordering or matching problem in Apex.

Refactor a correct Apex coding solution to improve readability, testability, and governor-limit safety.

Convert an ambiguous Salesforce design prompt into functional requirements, constraints, and measurable non-functional requirements.

Estimate record volumes, concurrency, throughput, storage growth, and API traffic for a proposed Salesforce solution.

Create a system-context diagram that assigns data ownership and responsibilities across Salesforce and external platforms.

Design the Salesforce data, automation, and security architecture for a subscriber-onboarding scenario.

Design integration flows and transaction boundaries for a high-volume order-management scenario.

Add observability, retry, reconciliation, and disaster-recovery mechanisms to a Salesforce solution.

Present and defend a Salesforce architecture in a structured ten-minute interview walkthrough.

Evaluate a Salesforce Developer job description to separate essential requirements from optional preferences and identify preparation gaps.

Rewrite résumé bullets as concise achievement statements supported by scope, technical decisions, and measurable impact.

Prepare a portfolio case study that explains a Salesforce problem, architecture, implementation, trade-offs, and results without exposing client-confidential information.

Deliver a concise professional introduction tailored to a mid-level Salesforce Developer role in a product company.

Answer project-depth questions by explaining personal ownership, debugging decisions, trade-offs, and production outcomes.

Construct STAR stories for ownership, conflict, failure, ambiguity, and cross-functional collaboration.

Run a structured mock-interview retrospective and convert weaknesses into a prioritized final preparation plan.