Select Two (Multi-Select) Questions

Database.save()

Why it fails: `Database.save()` is a non-existent method in Apex, making it syntactically invalid for executing any database transactions. It is tempting because developers frequently interact with standard `save()` methods, such as `StandardController.save()`, or object-oriented save routines in other frameworks where saving records is handled by an instance method rather than a static utility class. In Salesforce Apex, record persistence with partial success is actually handled by static methods on the `Database` class like `Database.insert()` or `Database.update()` paired with an allOrNone parameter set to false.

Database.commit()

Why it fails: `Database.commit()` does not exist in Apex as a method on the `Database` class, meaning it cannot process DML operations or offer partial success handling. It is tempting because developers often look for explicit transaction control methods to manage database state transitions and finalise multi-step operations. However, transaction commits in Apex are handled automatically by the platform upon successful execution of a trigger or transaction context, or explicitly managed using `Savepoint` and `Database.rollback()` when recovery logic is required.

Database.persist()

Why it fails: `Database.persist()` is tempting because developers frequently associate database-level terminology with data manipulation tasks, but it is not a valid Apex method on the `Database` class. It resembles standard persistence methods found in other ORM frameworks used to save records to a data store. However, Salesforce provides specific utility methods such as `Database.insert()` and `Database.update()` to execute DML operations with partial success capability via the `allOrNone` parameter, rendering this entirely fictitious method incorrect for handling record transactions.

WorkflowRule

Why it fails: WorkflowRule is a metadata type that represents declarative automation logic for evaluating record changes, rather than a data type capable of holding variable values in code. It is tempting because developers frequently interact with workflow rules alongside Apex when building business logic, making it easy to confuse configuration entities with programming constructs. It would be the correct choice when defining criteria-based actions in declarative setup menus to automate field updates or email alerts without writing custom code.

LightningComponent

Why it fails: LightningComponent is an application framework component type used to build dynamic web interfaces, not a scalar value holding a single piece of data such as an Integer or Boolean. Developers might mistakenly choose this option when dealing with modern user interface development in Salesforce, where Lightning web components represent the standard paradigm for building front-end views. However, primitive data types are reserved strictly for foundational values manipulated within business logic, meaning framework-level entities have no place in primitive type declarations.

Code Coverage Percentage.

Why it fails: Code coverage is actually aggregated and reviewed within the Developer Console's Tests tab or specific Apex class detail views rather than the Apex Test Execution page, making it incorrect for this specific layout. However, it remains tempting because developers frequently need to verify test coverage percentages to meet Salesforce deployment requirements. It would be the correct metric when evaluating whether classes satisfy the mandatory 75% overall coverage threshold prior to production migration.

User who initiated the test.

Why it fails: The Apex Test Execution page within the Salesforce Developer Console tracks the progress and outcomes of unit tests, displaying metrics such as test status, duration, failure messages, and code coverage percentages, rather than user audit trails. This option appears plausible because the Developer Console routinely logs executing users and transaction metadata in log panels and debug logs, which would typically record who initiated a manual or programmatic test run. However, the dedicated test execution interface aggregates execution results and performance data instead of user attribution, meaning user details must be retrieved via asynchronous Apex job records or event logs if required.

Executing SOQL queries inside a for loop iterating over all child records.

Why it fails: Placing a SOQL query inside a loop causes a separate database round-trip for every single iteration, which rapidly exhausts the synchronous governor limit of 100 queries. Developers are often tempted by this pattern when attempting to retrieve child records dynamically for every parent record processed in a collection. It would only be the correct choice if querying a tiny, fixed number of records outside governor limits, or when leveraging lazy loading in specific UI extensions where query counts are strictly controlled and bounded.

Calling Database.query() for every single record processed in a trigger.

Why it fails: Executing SOQL queries inside a loop or for every individual record triggers a distinct query against the database on each iteration, causing the transaction to rapidly exhaust the strict governor limit of 100 SOQL queries per transaction in bulk operations. This approach appears attractive when developers need to dynamically construct queries based on specific field values of individual records or implement polymorphic queries where filter criteria change per record. While `Database.query()` is the correct mechanism for constructing dynamic SOQL strings at runtime—such as building flexible search filters with variable user inputs—it must be supplied with a collection of values or a single aggregated string rather than being executed inside an iterative loop processing records.

Modify the Org's license type.

Why it fails: Licence types are fundamental contractual provisions managed directly through Salesforce billing agreements and provisioning teams within the production environment user interface rather than through developer tooling. Developers frequently use the Salesforce CLI to manage source code, execute automated testing scripts, and deploy metadata packages across scratch orgs and sandboxes. This option appears plausible because developers routinely provision and configure various sandbox editions and connected dev environments via terminal commands, making it tempting to assume administrative subscription parameters can be similarly modified via the command line.

Update user passwords.

Why it fails: The Salesforce CLI deploys and retrieves metadata, runs Apex tests, and executes SOQL queries against orgs; password resets require the user interface, Apex, or the SOAP API. Password management is an administrative identity task, not a CLI deployment or development capability.

Call Limits.getQueries() at the start of every trigger to abort if limits are near.

Why it fails: Relying on `Limits.getQueries()` fails because checking governor limits merely detects resource consumption rather than halting the logical loop, meaning the transaction will still exhaust CPU time or SOQL limits before stopping. This approach is tempting because it is a standard mechanism for monitoring overall transaction health and preventing runaway code in asynchronous batch batching or scheduled processing jobs where threshold guards are used to gracefully abort prior to hitting fatal limits.

Wrap all DML statements in a try-catch block that catches recursion exceptions.

Why it fails: Apex recursion surfaces as a System.LimitException for stack depth, not a catchable recursion exception, so try-catch cannot intercept it. It is tempting because try-catch is a standard defensive pattern, but it would be correct only for handling DmlException or callout errors, not for preventing recursive trigger re-entry.

Microsoft FrontPage 2003

Why it fails: Microsoft FrontPage 2003 lacks modern Node.js runtimes, ECMAScript modules, and Salesforce DX integration required to compile and deploy Lightning Web Component metadata. Developers historically utilised this legacy WYSIWYG editor for static HTML website design in an era predating modern component-based JavaScript frameworks. It would be the correct choice if you were maintaining legacy static web pages from the early 2000s without server-side logic, build pipelines, or Salesforce CLI integration, but it cannot handle modern Salesforce development workflows.

Eclipse IDE with the Force.com IDE v1 plugin

Why it fails: Eclipse IDE combined with the Force.com IDE v1 plugin relies on the legacy Metadata API and Tooling API architectures designed exclusively for Visualforce pages and Aura components, meaning it lacks the compiler, language server, and workspace extensions required to parse modern JavaScript, HTML templates, and configuration files inherent to Lightning Web Components. It is tempting because Salesforce historically recommended the Eclipse ecosystem for enterprise Force.com development, and it remains a functional choice for legacy Java-centric development or older Aura component projects that predate modern Salesforce DX tooling.

Dreamweaver MX with custom snippet extensions

Why it fails: Dreamweaver MX lacks modern ECMAScript compilation pipelines, integrated Salesforce DX command-line tooling, and the specific Language Server Protocol integrations required to validate modern web standards and Lightning Web Component decorators. Developers may find it tempting because it is a classic, highly customisable desktop HTML and CSS editor historically used for general web page authoring and basic template design. It would be the correct choice only when maintaining legacy static web sites from the early 2000s that rely on rudimentary tag insertion and manual FTP deployment without modern component frameworks.

Use standard Visualforce standardSetController inside the LWC JavaScript.

Why it fails: Visualforce standardSetController cannot be embedded directly inside Lightning Web Component JavaScript because it is a server-side controller extension tied to the legacy Visualforce lifecycle rather than a modular client-side component architecture. Developers often find this approach tempting because standardSetController provides out-of-the-box chunking, cursor management, and pagination logic for standard lists. It would be the correct choice when building classic Visualforce pages that require server-driven pagination over large sObjects without writing custom offset queries.

Directly mutate the server database on every page click.

Why it fails: Querying the server database on every page navigation operation introduces severe performance latency and violates efficient data handling patterns for client-side pagination controls in Salesforce. Developers are often tempted to implement direct database queries because this approach guarantees real-time data freshness, which is the correct architectural pattern for batch-processing jobs or processing high-volume financial transactions where stale data poses a critical compliance risk.

It speeds up test execution.

Why it fails: Enabling `SeeAllData=true` bypasses isolated test data architecture by granting access to pre-existing organisation records, which actually degrades test performance and causes unpredictable failures due to data dependency. Developers are often tempted to use this attribute when legacy code or complex third-party packages require existing records to function without manual setup. It WOULD be the correct choice exclusively when validating legacy functionality that relies on standard objects, price books, or metadata configurations that cannot be instantiated via Apex within a clean-data test context.

It is required for testing standard objects.

Why it fails: Standard objects do not require `@isTest(SeeAllData=true)` because unit tests operate on isolated test data by default, meaning developers can successfully create, query, and manipulate standard objects like Accounts and Contacts within standard execution contexts. This setting is tempting because developers often assume organisation-wide data access is mandatory when writing complex queries against standard objects that relate to pre-existing system records. However, it would only be the correct choice when testing functionality that strictly depends on pre-existing configuration data or specific historical records that cannot be generated programmatically within the test method.

It ignores all governor limits.

Why it fails: Using `@isTest(SeeAllData=true)` grants test methods access to pre-existing organisation data, which is tempting when legacy integration tests require existing records to execute without setup. However, this annotation has no effect on governor limits, which remain strictly enforced during test execution. Developers might mistakenly assume it relaxes execution boundaries, but it only disables data isolation. Consequently, tests failing due to SOQL limits will still fail regardless of whether this data visibility flag is enabled.

Hardcode specific record IDs assigned during @TestSetup into downstream test assertions.

Why it fails: Hardcoding record IDs generated in an `@TestSetup` method breaks unit tests because Salesforce assigns dynamic, non-deterministic database identifiers upon insertion that vary across execution contexts and target environments. This practice appears attractive when developers wish to establish explicit relational dependencies or predictable reference points for assertion queries without writing dynamic SOQL filters. In isolated scenarios where a static resource or external mock framework requires immutable external IDs or predefined integration keys, mapping hardcoded identifiers serves a valid purpose, but standard Apex testing demands dynamic retrieval via queries.

Call external REST callouts inside the @TestSetup method to fetch live seed data.

Why it fails: Test methods cannot perform live HTTP callouts to external services unless enclosed within a `Test.startTest()` and `Test.stopTest()` block, which is structurally impossible inside an `@TestSetup` method since these execute before test context boundaries. Developers are frequently tempted to fetch live seed data via REST callouts to populate realistic records dynamically and avoid hardcoding values. This approach is intended for production integration layers requiring real-time external synchronization, whereas unit tests demand isolation and determinism to prevent external network dependencies from causing intermittent test failures.

Hardcode record IDs in trigger logic to route specific test accounts.

Why it fails: Hardcoding record IDs directly into trigger logic to route specific test accounts fails because identifiers change across Salesforce environments, causing queries or conditional checks to break upon deployment to production. This approach is tempting because referencing specific IDs is useful for unit tests or debugging when a developer needs to target a precise sandbox record to verify execution paths. However, production deployment invalidates environment-specific identifiers, meaning developers must instead query Custom Metadata Types or Custom Settings to dynamically manage record routing without brittle hardcoded dependencies.

Use synchronous callouts directly inside before insert triggers.

Why it fails: Synchronous callouts inside triggers freeze database transactions while awaiting HTTP responses, hitting governor limits and blocking database operations during bulk execution. Developers are often tempted to use callouts to immediately fetch external data or synchronise records upon creation, which is a valid pattern when executed asynchronously using `@future(callout=true)` or Queueable interfaces to decouple external web service latency from the primary database transaction.

Place SOQL queries inside loops to ensure every record gets fresh data.

Why it fails: Executing SOQL queries inside a `for` loop triggers governor limits because Salesforce enforces a strict maximum of 100 queries per synchronous transaction. This approach is tempting because developers often need to evaluate changing field values or retrieve related child records dynamically for individual records during iterative processing. Such a pattern would theoretically be correct in single-record debugging contexts outside the Salesforce multi-tenant architecture, where governor limits do not apply and real-time database freshness per iteration is explicitly required.

SOQL supports traversing up to 10 levels of parent relationships.

Why it fails: SOQL relationship queries only permit traversing up to five levels of parent-to-child or child-to-parent relationships in a single query, making ten levels invalid. This limit often confuses developers because Salesforce does support up to ten levels of parent relationship traversal when constructing reports, formulas, or roll-up summaries in the declarative user interface. Consequently, it appears to be a plausible programmatic limit aligned with platform-wide schema depth rules, but SOQL strictly enforces a lower ceiling.

Parent-to-child queries use dot notation on the parent object.

Why it fails: Dot notation is actually used exclusively for child-to-parent queries to traverse up the relationship from a child record to fields on its parent, such as `Account.Name`. It is tempting because developers routinely use dot notation to access related fields in Apex and SOQL. This syntax would be the correct choice if you were querying fields on a parent object from the child, rather than retrieving a related list of child records from a parent.

Child-to-parent queries require subqueries.

Why it fails: Child-to-parent queries use dot notation directly on the base object rather than requiring subqueries. Developers often confuse this direction with parent-to-child queries, making this statement tempting because subqueries *are* indeed required when traversing from a parent object to retrieve its related child records.

Declaring every class with 'without sharing'.

Why it fails: Declaring classes 'without sharing' runs Apex in system mode, bypassing the record-level sharing rules that enforce CRUD and FLS restrictions. It is tempting when a class must access all records, but secure coding requires 'with sharing' or explicit schema checks instead.

Relying solely on Lightning Web Component HTML rendering tags.

Why it fails: Hiding elements in user interface templates solely prevents visual rendering in the browser rather than enforcing server-side enforcement. Developers often find this approach appealing because it quickly controls screen layout and hides unauthorized fields during standard user interactions, making it suitable for improving front-end usability and tailoring component displays. However, malicious users can easily bypass client-side visibility rules by directly querying the underlying Apex controller, leaving the application vulnerable to unauthorized data access unless explicit schema checks are performed on the server.

Flows cannot trigger subflows or call invocable actions.

Why it fails: Subflows and invocable actions are fully supported within Flow Builder, allowing developers to modularise complex logic and execute Apex actions seamlessly. This statement is tempting because developers often need to structure large automation routines into reusable components or bridge declarative paths with custom code, making subflows and invocable actions the correct choice when scaling a screen or record-triggered flow modularly.

Apex triggers execute significantly slower than record-triggered flows in all scenarios.

Why it fails: Record-triggered flows and Apex triggers do not exhibit a universal performance hierarchy where one is intrinsically slower across all execution contexts, making generalised speed comparisons invalid for architectural selection. This statement is tempting because developers often evaluate execution speed when deciding how to automate complex data transactions. Apex triggers would be the correct choice when processing high-volume bulk operations that require intricate error handling, custom wrapper classes, or complex callouts, where programmatic control over governor limits and memory management provides superior execution predictability compared to declarative tools.

Flow Builder is required when processing millions of records nightly in asynchronous batches.

Why it fails: Processing millions of records nightly requires the robust execution limits, bulkified data manipulation, and governor limit management inherent to asynchronous Apex queueable or batch jobs, rather than the visual execution engine of Flow Builder, which risks encountering transaction limits and performance bottlenecks at this scale. Conversely, this option is tempting because Flow Builder does support asynchronous paths and scheduled flows, making it the ideal choice for time-delayed automations or lower-volume record-triggered asynchronous processing where graphical debugging and rapid maintenance outweigh the need for programmatic batch infrastructure.

Disable sharing on all controller classes.

Why it fails: Disabling sharing on controller classes bypasses record-level security, which increases the risk of unauthorised data exposure rather than mitigating XSS vulnerabilities. Developers often utilise the `without sharing` keyword when they must perform system-level operations, such as accessing hidden records or processing background batch jobs that require elevated privileges to function correctly. This practice is entirely unrelated to the sanitisation of user-supplied input or the encoding of output fields required to prevent malicious script injection within the browser.

Set escape="false" on all output components to ensure proper rendering.

Why it fails: Setting `escape="false"` disables the built-in HTML encoding on Visualforce output components, which directly introduces Cross-Site Scripting vulnerabilities by allowing raw, potentially malicious user input to execute unescaped in the browser. Developers are often tempted to use this attribute when they need to render stored HTML markup or rich text formatting correctly on the page. In scenarios where you must safely display user-supplied content while preserving legitimate HTML tags, you should instead pass the string through a sanitisation library to strip out dangerous script elements rather than disabling platform-level encoding entirely.

Allows bypassing validation rules in production

Why it fails: Salesforce CLI deployments respect platform security architecture and cannot bypass validation rules in production environments, as data integrity enforcement remains mandatory regardless of the deployment tool used. Administrators often confuse deployment mechanisms with data bypass features because bypasses are typically configured using custom permission sets or trigger frameworks during data migration tasks. This option would be plausible if the scenario required executing a data-loader operation where specific validation rules needed to be temporarily disabled for a bulk data load via an API configuration file.

Automatically converts all code to Lightning Web Components

Why it fails: Salesforce DX and the command line interface do not translate AngularJS, Aura components, or Visualforce pages into modern Lightning Web Components, as code refactoring requires manual developer intervention to rewrite component controllers and markup. This feature targets developers modernising legacy user interfaces during framework migrations, where such tooling would assist in converting older Aura components or Visualforce pages into contemporary web standards if automated translation utilities were natively supported by the platform.

Before Insert and After Insert triggers on the losing record.

Why it fails: During a record merge operation, the winning record is updated while the losing record is deleted, meaning insert triggers never fire because no new records are created. This option appears tempting because developers often assume that combining records involves creating a fresh entity in the database that requires standard insert processing. In a standard workflow where a new record is deliberately created via cloning or web-to-lead conversion, `Before Insert` and `After Insert` triggers execute appropriately to validate and post-process the newly instantiated data.

Undelete triggers on both records.

Why it fails: A record merge operation deletes the losing record rather than placing it in the recycle bin, meaning `undelete` triggers never fire for the losers; this option seems plausible because developers often assume a merge involves restoring or combining archived records, and `undelete` triggers *would* execute if you manually restored a deleted record from the recycle bin rather than performing a standard duplicate consolidation.

Lead conversion triggers instead of merge triggers.

Why it fails: Merging records in Salesforce involves parent-child object consolidation rather than the distinct workflow of qualifying a prospect into an account, contact, and opportunity. This distractor is tempting because lead conversion also combines separate records and fires specific Apex events, making it a plausible mechanism when developers confuse the consolidation of duplicate records with the end-of-lifecycle transformation of a prospective customer.

Establishing a savepoint resets the SOQL query governor limit counter.

Why it fails: Setting a database savepoint using `Database.setSavepoint()` only manages the transactional state of database operations—allowing developers to roll back partial DML changes upon an exception—and has zero effect on governor limits, which track resource consumption across the entire execution context. This statement appears tempting because developers often associate savepoints with error recovery and transactional resets, leading to the false assumption that undoing database changes also reverts the SOQL query limit counter. In a scenario where multiple database queries must be conditionally retried, a savepoint correctly manages the data rollback, but query limits remain permanently incremented regardless of how many savepoints are established or rolled back.

Rolling back to a savepoint clears all governor limit exceptions already thrown.

Why it fails: Governor limit exceptions are fatal and unrecoverable; rolling back to a database savepoint using `Database.rollback()` reverses DML operations rather than resetting runtime execution thresholds or clearing thrown exceptions. Developers are frequently tempted by this because savepoints manage partial transaction state during complex operations, and this feature would theoretically be the correct choice if the requirement was to undo uncommitted database changes after a validation failure before continuing execution.

Blob

Why it fails: Blobs cannot serve as Map keys in Apex because they do not support value-based equality comparisons or deterministic hashing required for map lookups. Developers might attempt to use a Blob when handling binary data payloads, such as document attachments or encrypted tokens, where storing and retrieving data by its raw byte content is necessary. In scenarios requiring binary data storage, Blobs are the correct choice for representing file bodies or handling cryptographic operations, provided they are stored as map values rather than keys.

List<String>

Why it fails: Lists cannot be used as map keys because Apex map keys must be primitive data types, IDs, or sObjects that implement a deterministic hash code and equals contract. A `List<String>` is tempting when grouping multiple text values together as a composite identifier, such as matching a combination of region and product category. It would be the correct choice when you need to maintain an ordered collection of string elements, iterate through them sequentially, or store duplicate values rather than ensuring unique key lookup.

SObject

Why it fails: Using an `SObject` as a map key fails because Apex map keys must possess a stable hash code and immutable state to ensure reliable lookups, whereas `SObject` instances have mutable field values and dynamic states that can change during execution. Developers are often tempted to use `SObject` keys when grouping records by parent or child relationships without extracting a unique identifier field first. While an `SObject` would logically represent a record entity in scenarios requiring direct object-to-object mapping, Apex requires primitives, IDs, or custom serialisable types to guarantee hash stability.

Use single record DML statements inside a standard for-loop.

Why it fails: Executing database operations one record at a time within a loop causes Apex triggers to hit the strict governor limit of 150 DML statements per transaction whenever multiple records are processed in bulk. Developers often reach for this pattern because standard loops make record-by-record logic straightforward to read and write, and processing a single record individually is the correct approach when building targeted unit test assertions for isolated code paths outside of bulk operations.

Hardcode record IDs to query specific test records.

Why it fails: Hardcoding record IDs prevents a trigger from functioning across different environments, as IDs vary between sandboxes and production, thereby violating the requirement for bulkified, portable code. Developers often find this approach tempting when writing unit tests, where it serves to isolate specific data records for verification. While this technique facilitates targeted assertions within a controlled test class environment, it remains fundamentally incompatible with production triggers that must dynamically process arbitrary collections of records during bulk operations.

Annotate the trigger with @future to ensure asynchronous bulk processing.

Why it fails: Annotating a trigger with @future forces execution into a separate thread, which fails to address the requirement of processing records synchronously within the original transaction context. While developers often reach for this annotation to bypass DML or SOQL governor limits by offloading heavy processing to a background queue, it introduces latency and complicates error handling. This approach is intended for callouts to external services or complex operations that exceed synchronous execution time, rather than for ensuring standard bulkification within the primary trigger execution.