DEX-450 Build Applications Programmatically on the Salesforce Platform Exam Topics and Questions
These Salesforce Build Applications Programmatically on the Salesforce Platform (DEX-450) exam topics are organized according to official exam domains to help candidates quickly verify coverage and focus on assessment rather than theory. Each domain is paired with topic-wise DEX-450 sample questions that reflect how objectives are tested in the actual exam. This structure enables efficient review, targeted self-assessment, and rapid identification of weak areas when preparing for the Salesforce Build Applications Programmatically on the Salesforce Platform certification exam.
Let's Practice Free Salesforce DEX-450 Questions Aligned with Official Exam Topics
Apex is Salesforce's proprietary server-side language, and everything else in this exam sits on top of it. Before you can write triggers, classes, or DML logic, you need a working mental model of how Apex executes: what a transaction boundary is, what a governor limit does to your code, and why the platform enforces both. Get these foundations wrong and you will misread scenarios in every other topic. β What Apex is and how the platform shapes it Apex runs...
Apex is Salesforce's proprietary server-side language, and everything else in this exam sits on top of it. Before you can write triggers, classes, or DML logic, you need a working mental model of how Apex executes: what a transaction boundary is, what a governor limit does to your code, and why the platform enforces both. Get these foundations wrong and you will misread scenarios in every other topic.
β What Apex is and how the platform shapes it
Apex runs on Salesforce's multitenant infrastructure, and that fact drives every design decision the language makes. The platform cannot let one org monopolise shared resources, so it enforces governor limits at runtime: limits on SOQL queries, DML statements, CPU time, heap size, and more. A transaction is the unit of enforcement. Every line of Apex you write executes inside a transaction, and when that transaction ends, the counts reset. Understanding which limits apply per transaction versus per request, and which operations consume which buckets, is where candidates earn marks. The non-obvious detail is that limits apply to the entire transaction, not just to your method. A trigger fired by a bulk load, a future method called from a class, and inline Apex in a developer console all have different transaction boundaries. Knowing the difference between synchronous and asynchronous execution contexts matters because some limits are relaxed in asynchronous contexts. That distinction appears regularly in scenario questions.
β Language mechanics: types, control flow, and sObjects
Apex's type system is strongly typed and case-insensitive. The primitive types (Integer, Long, Double, Decimal, String, Boolean, Date, DateTime, Blob, ID) each have specific behaviours that affect how you write comparisons and assignments. Decimal is not the same as Double for currency arithmetic, and ID versus String matters when you are working with record identifiers. sObjects are the in-memory representations of Salesforce records. You instantiate them, set field values using dot notation, and pass them to DML operations. The relationship between an sObject type and its corresponding database object is one-to-one, and knowing which standard objects map to which API names avoids confusion in code-reading questions. Control statements in Apex behave as they do in Java: if/else, for loops (traditional and list-style), while, and do-while. The for-loop variant that iterates directly over a SOQL query result is particularly important because it processes records in batches internally, helping you stay inside governor limits when dealing with large data sets.
How Apex Coding is tested
Items in this topic present short code blocks and ask you to identify what happens at runtime, often targeting governor limit behaviour. The trap is treating Apex as if it were standard Java: the language looks familiar, but the execution context is different. Items reward candidates who can trace a transaction boundary, spot a limit violation before it happens, and distinguish which context (synchronous vs. asynchronous) a given piece of code runs in.
Code-reading questions will show you a loop or a DML call and ask you to predict an outcome. The strongest responses come from candidates who apply governor limit rules methodically rather than relying on intuition. A common loss point is confusing per-transaction limits with per-request limits, or missing that a bulk operation multiplies the number of times a block executes. Questions about data types test precision: candidates who treat Decimal and Double as interchangeable, or who ignore the ID type's validation behaviour, will choose weaker options. Practise reading code snippets cold, without running them.
The ITExamsTopics practice test for this exam covers Apex Coding alongside every other topic in the syllabus. Working through a full bank lets you see exactly which governor limit scenarios trip you up most often, so you can focus revision where it counts rather than re-reading material you already know.
The question below targets a specific Apex runtime behaviour. Work through it carefully before checking where your reasoning lands.
What are two characteristics related to formulas?
Choose 2 answers
Once you understand how Apex executes, the next pressure point is how it reads data. SOQL and SOSL are both query languages, but they solve different problems and the exam tests whether you know which one to reach for. Mixing them up in a scenario question costs marks. This topic also carries the relationship query patterns that catch candidates who learned SOQL from a single-object perspective. β SOQL fundamentals and processing results SOQL is a SELECT-based language scoped to a...
Once you understand how Apex executes, the next pressure point is how it reads data. SOQL and SOSL are both query languages, but they solve different problems and the exam tests whether you know which one to reach for. Mixing them up in a scenario question costs marks. This topic also carries the relationship query patterns that catch candidates who learned SOQL from a single-object perspective.
β SOQL fundamentals and processing results
SOQL is a SELECT-based language scoped to a single object (plus its relationships). A basic query returns a list of sObjects, and you process that list in Apex using loops or direct index access. The governor-limit-aware pattern is the SOQL for-loop, which fetches records in chunks rather than loading the entire result set into heap memory at once. Knowing when to use it versus a simple List assignment is a practical decision the exam tests in scenario form. Dynamic SOQL, built at runtime using Database.query() with a string argument, adds flexibility but also introduces the risk of SOQL injection. The exam expects you to understand why binding variables (using the colon syntax) are safer than string concatenation when constructing dynamic queries. The distinction between a static query embedded in Apex and a dynamically constructed one matters both for security and for governor limit counting: both consume the same per-transaction query limit.
β Relationship queries: navigating object graphs
Relationship queries are where candidates lose the most marks in this topic. A child-to-parent query uses dot notation in the SELECT clause to traverse up the relationship: you pull a field from a parent record in the same query that fetches the child. A parent-to-child query uses a nested SELECT (a subquery) to pull related child records inside the parent's result. The direction of traversal changes the syntax completely, and the exam will show you both and expect you to identify which is which. Standard relationships use predefined relationship names (for example, Account on a Contact record). Custom relationships use the __r suffix in place of __c. Getting the relationship name wrong means your query returns nothing rather than an error in some contexts, which is a subtle failure mode worth knowing. Polymorphic relationships, where a field can point to more than one object type, add another layer: the TYPEOF keyword in SOQL handles them.
β SOSL: multi-object search
SOSL is a search language, not a query language. It searches indexed text fields across multiple objects in a single call, returning a list of lists: one list per object type you specify. The practical use case is a search bar that needs to find matching records regardless of object. Where SOQL is precise (you know which object and which field to filter), SOSL is broad (you know a keyword but not necessarily which object holds it). The exam tests the syntax difference: SOSL uses FIND with a search term, then IN to specify which field group to search (ALL FIELDS, NAME FIELDS, EMAIL FIELDS, PHONE FIELDS), then RETURNING to name the objects and fields you want back. A common trap is applying SOQL logic to a SOSL question or vice versa. The return type difference matters in Apex: a SOQL query returns List<SObject>, while a SOSL search returns List<List<SObject>>. That type mismatch will break code if you confuse the two.
How Org Data Retrieval Using SOQL & SOSL is tested
This topic tests syntax recognition, result-type awareness, and the ability to choose between SOQL and SOSL given a described scenario. Items present a business requirement (find all records matching a keyword across objects, or retrieve child records along with their parent's name) and ask you to identify the correct query structure or the correct Apex construct to process the result.
Items reward candidates who know the return type of each query language and can trace how that type flows into subsequent Apex code. A frequent loss point is relationship query direction: candidates who have only written child-to-parent queries will misread a parent-to-child scenario. Another trap is dynamic SOQL security: items will describe a scenario where user input feeds a query, and the strongest option uses bind variables rather than concatenation. Governor limits appear here too. Queries inside loops are a classic anti-pattern, and items will present code where a SOQL call sits inside a for-loop body, expecting you to identify the problem and know the fix.
Seeing the range of SOQL and SOSL question styles before exam day matters. The ITExamsTopics practice test lets you try a free demo first, so you can judge the item style and difficulty before committing to the full bank.
The question below presents a data retrieval scenario. Read the requirements carefully before deciding which language and syntax applies.
A developer is asked to prevent anyone other than a user with Sales Manager profile from changing the Opportunity Status to Closed Lost if the lost reason is blank.
Which automation allows the developer to satisfy this requirement in the most efficient manner?
Reading data is only half the picture. DML is how Apex writes back to the database, and the exam tests both the mechanics and the error-handling discipline around it. Candidates who treat DML as a simple save operation miss the nuances that scenario questions are designed to expose: when to use the Database class methods instead of DML statements, and what happens to a transaction when a DML error occurs. How Org Data Manipulation Using DML is tested DML items...
Reading data is only half the picture. DML is how Apex writes back to the database, and the exam tests both the mechanics and the error-handling discipline around it. Candidates who treat DML as a simple save operation miss the nuances that scenario questions are designed to expose: when to use the Database class methods instead of DML statements, and what happens to a transaction when a DML error occurs.
How Org Data Manipulation Using DML is tested
DML items are scenario-driven. You will be shown a block of Apex that performs insert, update, upsert, delete, undelete, or merge operations and asked to predict the outcome, identify the error-handling gap, or choose between a DML statement and a Database class method. Items reward candidates who understand that DML statements throw exceptions on failure (rolling back the entire transaction unless caught), while Database methods with the allOrNone parameter set to false allow partial success and return result objects you can inspect record by record.
The biggest loss point is not knowing when partial success is appropriate and how to check SaveResult or UpsertResult objects afterward. Candidates who assume all DML either fully succeeds or fully fails will pick weaker options on error-handling questions. Governor limits apply here too: the exam expects you to know the per-transaction DML statement limit and to recognise when a loop-based DML pattern will breach it. Bulkifying DML, collecting records into a list and operating on the list once, is the pattern items reward over single-record operations inside loops.
DML error-handling is a narrow area where a handful of missed questions can reveal a real gap. Using the ITExamsTopics practice test to target this topic alone, without re-reading the whole chapter, is a faster way to confirm you have it covered.
The question below centres on a DML operation and its outcome. Think through the transaction behaviour before selecting your answer.
Writing code that works in a sandbox is only the starting point. Deployment is about moving that code safely into production, and the exam expects you to know the available mechanisms and when each one is appropriate. Change Sets, packaging formats, Salesforce DX, and the DevOps Center all solve the same underlying problem in different ways, and the distinctions between them are exactly what gets tested. β Change Sets and the packaging spectrum Change Sets are the point-and-click deployment method:...
Writing code that works in a sandbox is only the starting point. Deployment is about moving that code safely into production, and the exam expects you to know the available mechanisms and when each one is appropriate. Change Sets, packaging formats, Salesforce DX, and the DevOps Center all solve the same underlying problem in different ways, and the distinctions between them are exactly what gets tested.
β Change Sets and the packaging spectrum
Change Sets are the point-and-click deployment method: you build a set of components in one org and deploy it to a connected org. They require an established deployment connection and do not support version control natively. They are appropriate for straightforward org-to-org moves but become unwieldy for complex, multi-developer workflows. Packaging gives you a different model. An unmanaged package is a one-time transfer of components: the recipient can modify everything, but there is no upgrade path. A managed package is a versioned, installable unit distributed through AppExchange, where the publisher controls what subscribers can modify and can push upgrades. An unlocked package sits between the two: it is version-controlled and upgradeable, but the installing org retains full edit access to its components. The exam tests your ability to match a described scenario to the right packaging type. The key discriminators are upgrade support, edit access after installation, and distribution model.
β Salesforce DX and the DevOps Center
Salesforce DX reframes development around source control as the system of record rather than the org. The scratch org is the DX unit of development: a short-lived, configurable org spun up from source, used for a feature branch, then discarded. The Salesforce CLI drives the workflow, and metadata is stored in a source format that maps more cleanly to version control systems than the older metadata API format. The DevOps Center is Salesforce's native UI layer on top of DX concepts. It brings a pipeline view to the deployment process, tracking work items through stages from development to production without requiring every team member to use the CLI directly. The exam distinguishes between using the DevOps Center as a tool and understanding the underlying DX model it exposes. Candidates who know DX only through the CLI may be surprised by DevOps Center questions that describe the same concepts through a different interface. Know both the model and its surfaces.
How Deployment is tested
Deployment items are scenario-based: a team has a described workflow, a set of constraints (version control required, AppExchange distribution planned, recipient needs to customise components), and you choose the deployment mechanism that fits. Items reward matching the mechanism to the constraint, not just naming the mechanisms.
The trap is treating all deployment options as equivalent alternatives. Change Sets, packages, and DX are not interchangeable, and the exam will describe situations where one is clearly inappropriate. Candidates who memorise the names without understanding the constraints each option imposes will find the scenario questions harder than expected. A common loss point is the managed versus unlocked package distinction: both support versioning, but their post-install edit rights and distribution models differ, and items will hinge on exactly that difference. The DevOps Center questions tend to test conceptual understanding of the pipeline model rather than CLI commands, so focus on what each stage represents and how work moves through it.
The ITExamsTopics practice test covers all deployment scenarios across the full topic range. Working through timed conditions on deployment questions is particularly useful here, because the scenario descriptions are longer than average and time pressure changes how carefully you read them.
The question below describes a deployment requirement. Match the constraint in the scenario to the mechanism before committing to an answer.
Triggers are where Apex meets the database event model. Every time a record is inserted, updated, deleted, or undeleted, Salesforce can fire Apex code automatically, and the exam tests whether you understand how to write that code safely. The syntax is specific, the context variables are non-negotiable, and the use-case boundaries matter. Candidates who have written triggers in practice sometimes over-rely on intuition here and miss the definitional precision the exam demands. β When triggers fire and what they are...
Triggers are where Apex meets the database event model. Every time a record is inserted, updated, deleted, or undeleted, Salesforce can fire Apex code automatically, and the exam tests whether you understand how to write that code safely. The syntax is specific, the context variables are non-negotiable, and the use-case boundaries matter. Candidates who have written triggers in practice sometimes over-rely on intuition here and miss the definitional precision the exam demands.
β When triggers fire and what they are for
A trigger is bound to a single sObject and fires on one or more of seven events: before insert, before update, before delete, after insert, after update, after delete, and after undelete. The before and after distinction is fundamental. Before triggers fire before the record is written to the database, so you can modify field values on the records in memory. After triggers fire after the record is committed, so the record ID is available and you can safely reference related records. Choosing the wrong timing in a scenario question leads to a wrong answer. Trigger use cases cluster around logic that cannot be expressed in declarative tools: cross-object field updates that Flow cannot handle, complex validation that requires querying related records, and integration callouts. The exam expects you to distinguish between what belongs in a trigger and what belongs in a declarative automation, because choosing the wrong tool is itself a testable error.
β Syntax and context variables
Trigger syntax has a fixed structure: the trigger keyword, a name, the object it acts on, and a comma-separated list of events in parentheses. Inside the trigger body, Salesforce provides context variables through the Trigger namespace. Trigger.new holds the list of new versions of records being processed (available in insert and update contexts). Trigger.old holds the previous versions (available in update and delete contexts). Trigger.newMap and Trigger.oldMap give you the same records keyed by ID, which is essential when you need to look up a specific record efficiently rather than iterating the full list. Trigger.isBefore and Trigger.isAfter, along with Trigger.isInsert, Trigger.isUpdate, Trigger.isDelete, and Trigger.isUndelete, let you branch logic inside a single trigger that handles multiple events. The exam will present trigger bodies and ask which context variable is appropriate for a given operation. Knowing which variables are populated in which event context is not optional knowledge.
How Apex Trigger Essentials is tested
Trigger items split between syntax recognition and scenario judgement. Syntax items show you a trigger definition and ask you to spot what is wrong or what a given context variable contains at that point in execution. Scenario items describe a business requirement and ask whether a trigger is the right tool, and if so, which event and which context variable applies.
Items reward candidates who can read a trigger definition and immediately identify the event context, the available variables, and the timing relative to the database write. The most common loss point is confusing before and after contexts: candidates who reach for Trigger.new in an after delete context, or who try to modify Trigger.new values in an after trigger, will select weaker options. A second trap is bulk awareness. Triggers fire once per transaction, not once per record, so Trigger.new is always a list. Code written as if only one record arrives at a time is a recognisable anti-pattern, and the exam tests whether you can spot it.
Trigger context variable questions have a specific pattern that becomes easier to recognise with repetition. The ITExamsTopics practice test gives you enough volume across this topic to spot that pattern in your own results before the real exam.
The question below puts a trigger scenario in front of you. Pay attention to the event context before choosing your answer.
Triggers handle events; classes handle everything else. An Apex class is the primary unit of reusable logic on the platform, and the exam tests your understanding of how classes are structured, what controls their data access, and how annotations change their behaviour. This topic ties together the earlier material: a well-structured class is how you keep trigger logic testable and governor-limit-safe. β Class structure and use cases An Apex class is a blueprint for objects, following a syntax close to...
Triggers handle events; classes handle everything else. An Apex class is the primary unit of reusable logic on the platform, and the exam tests your understanding of how classes are structured, what controls their data access, and how annotations change their behaviour. This topic ties together the earlier material: a well-structured class is how you keep trigger logic testable and governor-limit-safe.
β Class structure and use cases
An Apex class is a blueprint for objects, following a syntax close to Java. It has an access modifier, a class keyword, a name, and a body containing properties and methods. The access modifier controls visibility: global classes are accessible from any context including managed packages, public classes are accessible within the same namespace, private classes are scoped to the file, and protected applies within inheritance hierarchies. Use cases for classes span almost every programmatic feature on the platform: utility libraries, service layers that encapsulate DML and query logic, handler classes called from triggers, controller classes that back Visualforce pages or Lightning components, and batch or scheduled job implementations. The exam expects you to match a described use case to the appropriate class type or access level. Candidates who treat all classes as interchangeable will miss the questions that hinge on why a global modifier is required for a managed package component or why a private class cannot serve as a Visualforce controller.
β Data access and annotations
Apex runs in system mode by default, meaning it ignores the running user's field-level and object-level permissions. The with sharing and without sharing keywords change this behaviour at the record-access level: with sharing enforces the running user's sharing rules, without sharing bypasses them. Omitting a sharing declaration inherits the context of the calling code, which can produce unexpected results in a chain of class calls. The exam tests these distinctions in security-scenario questions where the requirement specifies that user permissions must or must not be respected. Annotations extend class and method behaviour without changing the underlying logic. The @AuraEnabled annotation exposes a method to Lightning components. @future marks a method for asynchronous execution, with its own governor limit profile. @InvocableMethod makes a method callable from Flow. @TestVisible allows test classes to access private members without changing production access modifiers. Each annotation has constraints, and the exam will present scenarios where the wrong annotation fails silently or throws a runtime error.
How Apex Class Essentials is tested
Class items test access modifier selection, sharing keyword behaviour, and annotation applicability. Scenario items describe a requirement (expose logic to a Flow, run code asynchronously, enforce user permissions on a query) and ask you to identify the class structure or annotation that satisfies it.
Items reward precise knowledge of what each sharing keyword does and when the absence of one creates a security gap. A common trap is the inherited sharing scenario: candidates who know with sharing and without sharing but have not considered the omitted-declaration case will misjudge what happens when a sharing-unspecified class is called from a with sharing context. Annotation questions test constraints as much as purpose. @future methods cannot return values and cannot accept sObject parameters directly, for example, and items will describe a design that violates one of those constraints. The strongest option corrects the design rather than working around it. Candidates who have only memorised what annotations do, without knowing what they prohibit, will find these items harder than expected.
The ITExamsTopics practice test covers Apex Class Essentials across the full question bank. If you want to check this specific topic without reviewing everything, the practice test lets you gauge your accuracy here before deciding whether deeper revision is needed.
The question below tests a class-level design decision. Read the requirement in the scenario before ruling options in or out.
Class design sets the rules; order of execution determines when those rules actually run. Salesforce processes a saved record through a fixed sequence of steps, and that sequence interacts with triggers, validation rules, workflow, and Flow in ways that produce non-obvious results when you get the ordering wrong. Add Platform Events to the picture and you have an asynchronous communication layer that crosses transaction boundaries, which introduces its own set of exam-testable constraints. β The order of execution and its...
Class design sets the rules; order of execution determines when those rules actually run. Salesforce processes a saved record through a fixed sequence of steps, and that sequence interacts with triggers, validation rules, workflow, and Flow in ways that produce non-obvious results when you get the ordering wrong. Add Platform Events to the picture and you have an asynchronous communication layer that crosses transaction boundaries, which introduces its own set of exam-testable constraints.
β The order of execution and its trigger interactions
When a record is saved, Salesforce runs through a defined sequence: system validation, before triggers, custom validation rules, duplicate rules, after triggers, assignment rules, auto-response rules, workflow rules, processes, escalation rules, and then the final database commit. The exam does not expect you to recite every step, but it does expect you to place triggers correctly relative to validation rules and workflow. The practical implication is that a before trigger fires before custom validation, so code in a before trigger can set a field value that a validation rule then evaluates. An after trigger fires after validation, so it cannot prevent a save by modifying field values on the record in memory. That timing distinction is exactly what scenario questions exploit. When a trigger causes another DML operation, the order of execution runs again for the affected records, which can produce recursive trigger invocations. Knowing that recursion is possible, and that Apex offers no automatic recursion guard, is important context for both this topic and the trigger design topics that follow.
β Transaction lifecycle and Platform Events
A transaction begins when Apex starts executing and ends when all synchronous work is committed or rolled back. Within that boundary, every governor limit counter accumulates. If an unhandled exception occurs, the entire transaction rolls back, including any DML you performed earlier in the same execution. This is the core tension in error handling: you want to log the failure, but if the transaction rolls back, your log record disappears with it.
Platform Events solve this problem. A Platform Event is a published message that travels outside the current transaction. Publishing a Platform Event succeeds even when the surrounding transaction fails, because the event is committed independently. This makes Platform Events the standard pattern for durable error logging: write the error details to an event, publish it, and a separate subscriber persists the log regardless of what happens to the originating transaction. The exam tests both the conceptual reason Platform Events cross transaction boundaries and the practical steps to publish and subscribe to them in Apex.
How Order of Execution, Apex Transactions, & Platform Events is tested
Items in this topic present a multi-step save scenario and ask you to predict which automation fires first, or why a field value set in one step is or is not visible to a later step. The trap is assuming that triggers always run before or after all declarative automation: the actual sequence is more granular, and items are written to expose gaps in that granularity.
Items reward candidates who can place a before trigger relative to a validation rule, or who understand why an after trigger cannot modify the record that fired it. A frequent loss point is the rollback question: candidates who assume a caught exception preserves earlier DML will select weaker options on error-handling scenarios. Platform Event questions test the transaction-boundary behaviour specifically. Items reward knowing that a published event survives a transaction rollback and that a subscriber runs in a separate execution context with its own governor limits. Candidates who treat Platform Events as ordinary DML will misjudge both the durability and the limit profile of the pattern.
Order of execution questions depend on recognising a specific sequence under scenario pressure. The ITExamsTopics practice test lets you work through this topic across enough variations to see which steps in the sequence you are consistently misplacing.
The question below turns on the sequence in which Salesforce processes a record save. Trace the steps before committing to an answer.
Salesforce requires a minimum code coverage threshold before any Apex can be deployed to production, so testing is not optional housekeeping. The exam treats it as a discipline with its own rules: how test data must be created, how tests must be isolated from org data, and what patterns make a test meaningful rather than merely coverage-satisfying. Candidates who have written tests only to hit a percentage will find the best-practices questions harder than expected. β The testing framework and...
Salesforce requires a minimum code coverage threshold before any Apex can be deployed to production, so testing is not optional housekeeping. The exam treats it as a discipline with its own rules: how test data must be created, how tests must be isolated from org data, and what patterns make a test meaningful rather than merely coverage-satisfying. Candidates who have written tests only to hit a percentage will find the best-practices questions harder than expected.
β The testing framework and test data
Apex tests live in classes annotated with @isTest. A test method is annotated with @isTest (or the older testMethod keyword) and must be void. The framework runs test methods in isolation: by default, a test has no access to org data, which is both a protection and a constraint. You must create every record your test needs within the test itself, or supply it through a test data factory. The @testSetup annotation lets you define a single setup method whose data is available to all test methods in the class, with each method getting a rolled-back copy. This pattern reduces the cost of repeated data creation across many test methods. Test data factories are a best practice: a separate @isTest utility class with static methods that return configured sObjects, so multiple test classes can share the same creation logic without duplicating it. The exam expects you to know why org data is excluded by default and when the SeeAllData annotation is used, including why its use is discouraged for most scenarios.
β Writing, running, and evaluating tests
A useful test does three things: arranges data, executes the code under test, and asserts the outcome. The System.assert family (assertEquals, assertNotEquals, assert) is how you verify results. A test that executes code without asserting anything can satisfy coverage requirements but will never catch a regression. The exam distinguishes between coverage and correctness: a test that asserts nothing is not a good test, and items will ask you to identify what is missing from a described test class.
Test.startTest() and Test.stopTest() bracket the code under test and reset governor limit counters, giving the code inside a fresh set of limits. They also force asynchronous operations (future methods, batch jobs) to execute synchronously within the test, which is the only way to assert their results. Knowing that stopTest() is what triggers the asynchronous execution, not startTest(), is a precision point the exam tests. Running tests from the Developer Console, the Salesforce CLI, or Setup each surfaces code coverage data, and the exam expects you to understand that coverage is measured at the line level, not the method level.
How Apex Testing is tested
Testing items are scenario-driven: you are shown a test class structure and asked to identify what is wrong, what is missing, or which pattern satisfies a stated requirement. Items reward candidates who distinguish between a test that achieves coverage and a test that verifies behaviour. The most common loss point is the assertion gap: candidates who see a test that calls production code and assume it is complete will miss the missing assert.
Items on test data creation reward knowing the difference between @testSetup and inline data creation, and when SeeAllData is and is not appropriate. Asynchronous testing is a reliable exam area: items reward knowing that Test.stopTest() is what forces a future method to complete, and that without it the async operation never runs within the test context. Best-practice questions tend to hinge on isolation: a test that queries live org records is fragile and the exam treats it as a design flaw. Candidates who have only written tests against sandbox data with SeeAllData will find the isolation questions less intuitive.
Coverage numbers tell you nothing about which testing concepts you have actually mastered. Working through the ITExamsTopics practice test under timed conditions on this topic shows you where your testing knowledge has gaps that re-reading a trailhead module would not reveal.
The question below presents a test class scenario. Assess what the test does and does not verify before selecting your answer.
Knowing the language is different from knowing how to apply it well. This topic shifts from mechanics to judgement: given a requirement, which patterns produce code that stays inside governor limits, remains testable, and does not break when data volumes grow? The exam presents suboptimal designs and asks you to identify what is wrong and what a better approach looks like. The sub-topics deliberately overlap with earlier material, but the emphasis here is on design decisions rather than syntax. β...
Knowing the language is different from knowing how to apply it well. This topic shifts from mechanics to judgement: given a requirement, which patterns produce code that stays inside governor limits, remains testable, and does not break when data volumes grow? The exam presents suboptimal designs and asks you to identify what is wrong and what a better approach looks like. The sub-topics deliberately overlap with earlier material, but the emphasis here is on design decisions rather than syntax.
β Query and DML efficiency
The most examinable efficiency principle is bulkification: never place a SOQL query or a DML statement inside a loop. A loop that fires one query per iteration will breach the per-transaction SOQL limit as soon as the data volume is large enough, and in a bulk operation that threshold arrives quickly. The correct pattern collects the IDs or values you need, queries outside the loop with an IN filter, and processes the results in memory. The same logic applies to DML: accumulate records in a list and perform a single operation on the list.
Beyond loop placement, query efficiency involves selecting only the fields you need (avoiding SELECT * patterns where possible), using relationship queries to retrieve parent or child data in a single call rather than issuing a second query inside a loop, and choosing between a SOQL for-loop and a list assignment based on the expected result set size. Large result sets belong in a SOQL for-loop to avoid heap size violations. The exam will present code that violates one of these patterns and ask you to identify the problem or supply the fix.
β Trigger and class design
Trigger design best practice converges on a single rule: one trigger per object. Multiple triggers on the same object fire in an undefined order, which makes behaviour unpredictable when they interact. The handler class pattern addresses this: the trigger itself contains minimal logic, delegating immediately to a class method that can be tested independently. This separation also makes it possible to write a test that calls the handler directly without needing to fire a trigger event, which simplifies test data setup.
Class design for efficiency means separating concerns: a service class handles business logic, a selector class (or repository) handles queries, and a domain class handles record-level operations. This layering is not mandatory syntax, but the exam tests whether you recognise why mixing query logic, DML, and business rules in a single method creates a testing and maintenance problem. Candidates who have written all-in-one trigger bodies will recognise the anti-pattern when they see it described. The exam rewards knowing not just that separation is good practice, but why: testability, reusability, and the ability to enforce governor-limit-safe patterns at the layer boundary.
How Design Strategies for Efficient Apex Solutions is tested
Items in this topic present code or a described architecture and ask you to evaluate it. The question is rarely about syntax: it is about whether the design holds under load, remains testable, and respects governor limits. Items reward candidates who can identify a SOQL query inside a loop as a limit risk, a multi-trigger setup as an ordering hazard, or a monolithic trigger body as a testability problem.
The trap is that the code shown often works correctly for a single record. The exam is asking whether it works correctly at scale, and candidates who evaluate correctness in isolation rather than under bulk conditions will select weaker options. Design questions about class structure tend to hinge on the handler pattern: items reward the separation of trigger logic from handler logic, and candidates who have only written logic directly in trigger bodies will find the rationale questions harder. A second common loss point is the query placement question: candidates who know bulkification in principle but cannot spot a violation in a presented code block will miss marks that careful code-reading would recover.
Design pattern questions are harder to study from documentation alone because the exam tests recognition under time pressure. The ITExamsTopics practice test gives you the volume of varied scenarios needed to make pattern recognition automatic rather than effortful.
The question below asks you to evaluate a design decision. Consider governor limit behaviour and testability before choosing.
The previous topic covered design principles in general terms. This one narrows to a specific and frequently underestimated skill: knowing when not to write Apex at all. Salesforce's declarative tools have expanded significantly, and the exam now tests whether you can identify the boundary between what Flow or other no-code tools handle well and where Apex becomes necessary. Getting that boundary wrong in a scenario question costs marks in both directions. How Apex Trigger Design Strategies is tested With only...
The previous topic covered design principles in general terms. This one narrows to a specific and frequently underestimated skill: knowing when not to write Apex at all. Salesforce's declarative tools have expanded significantly, and the exam now tests whether you can identify the boundary between what Flow or other no-code tools handle well and where Apex becomes necessary. Getting that boundary wrong in a scenario question costs marks in both directions.
How Apex Trigger Design Strategies is tested
With only two sub-topics, this area is focused but not shallow. Items present a business requirement and ask you to decide whether it belongs in a declarative tool, in Apex, or in a combination of both. The discriminating factor is usually something the declarative tool cannot do: a cross-object update that Flow's current record scope cannot reach, a conditional callout, or a calculation that requires iterating a large related list in memory.
Items reward candidates who know the current capability boundary of Flow and Record-Triggered Automation, not a historical version of it. Salesforce has extended declarative tools repeatedly, and an answer that was correct two years ago (reach for Apex for this) may now reflect a weaker option because Flow can handle it natively. The second sub-topic tests the inverse: given existing Apex, where can you replace or supplement it with declarative logic to reduce code surface area and maintenance cost? Items reward recognising that the goal is the right tool for the requirement, not a preference for one approach over the other. Candidates who default to Apex for everything will select weaker options on scenarios where a Flow solution is clearly more appropriate.
The ITExamsTopics free demo lets you sample the question style for this topic before purchasing the full bank, which is useful here because the no-code versus pro-code boundary questions have a specific framing that is worth seeing in advance.
The question below presents a business requirement. Evaluate whether the declarative or programmatic path better satisfies the stated constraints.
The previous topics have all operated server-side. User Interface Development moves to the client layer, where Lightning Web Components run in the browser and communicate with Salesforce data through a framework that has its own rules. This is the most syntax-dense topic in the exam: component structure, data binding, event propagation, and the wire service each have specific behaviours, and the exam tests all of them in scenario and code-reading form. β The Lightning Component Framework and LWC structure Lightning...
The previous topics have all operated server-side. User Interface Development moves to the client layer, where Lightning Web Components run in the browser and communicate with Salesforce data through a framework that has its own rules. This is the most syntax-dense topic in the exam: component structure, data binding, event propagation, and the wire service each have specific behaviours, and the exam tests all of them in scenario and code-reading form.
β The Lightning Component Framework and LWC structure
Lightning Web Components are built on web standards: HTML templates, JavaScript classes, and CSS scoped to the component. The framework layer adds Salesforce-specific capabilities: the wire service for reactive data retrieval, decorators for property binding, and a set of base components that implement standard UI patterns. The exam distinguishes LWC from the older Aura component model. Both run on the Lightning platform, but their programming models differ significantly. LWC uses standard JavaScript class syntax and leverages native browser features; Aura uses a proprietary event and attribute model. Questions about component creation assume LWC unless the scenario specifies otherwise.
A component consists of at minimum an HTML file and a JavaScript file sharing the same name. The HTML template uses a specific syntax for data binding and conditional rendering. The JavaScript file exports a class that extends LightningElement. Decorators control how properties behave: @api exposes a property to a parent component, @track was historically used for reactive object tracking (though this behaviour is now largely default), and @wire connects a property or function to a data source.
β Retrieving and displaying record data
The wire service is the primary mechanism for retrieving Salesforce data reactively in an LWC. You annotate a property or function with @wire, pass it an Apex method or a Lightning Data Service adapter, and the framework automatically re-renders the component when the data changes. The wire service handles caching and re-fetching; you handle what to display when data is loading and what to display when an error occurs.
Lightning Data Service adapters (getRecord, getFieldValue, and related imports from lightning/uiRecordApi) let you retrieve record data without writing an Apex method at all. The exam tests when to use a wire-connected Apex method versus a Lightning Data Service adapter, and the discriminating factor is usually whether the data shape matches what the standard adapters provide. For standard record retrieval, the adapter is preferred. For complex queries, aggregations, or multi-object results, a wire-connected Apex method annotated with @AuraEnabled(cacheable=true) is required. The cacheable constraint is not optional for wire: a non-cacheable method cannot be wired.
β Events, DML operations, and surfacing components
LWC events follow a DOM-based model. A child component dispatches a CustomEvent, and a parent component listens for it using an event handler attribute in the template. Events propagate upward through the component tree by default; setting bubbles and composed on the event changes how far it travels. The exam tests event direction: data flows down through properties, events flow up through the component hierarchy. Candidates who apply Aura's event model to LWC questions, or who assume events propagate in both directions by default, will select weaker options.
For DML operations, an LWC calls an Apex method imperatively (not through the wire service, since wire is read-only). The method must be @AuraEnabled, and the call returns a Promise. Error handling uses the catch block of that Promise chain. Surfacing a component means controlling where it appears: the targetConfigs section of the component's metadata file specifies which contexts (App Builder, record pages, communities, flow screens) the component supports. Each surface has its own supported property types, and the exam tests which metadata configuration exposes a component to a given context.
How User Interface Development is tested
LWC items are a mix of code-reading and scenario questions. Code-reading items show you a template or a JavaScript class and ask you to identify a missing decorator, an incorrect event handler, or an invalid wire configuration. Scenario items describe a UI requirement and ask which framework feature, adapter, or event pattern satisfies it.
Items reward precise knowledge of decorator purpose: candidates who confuse @api and @wire, or who do not know that @wire requires cacheable=true on the backing Apex method, will select weaker options on data retrieval questions. Event direction is a reliable loss point. Candidates who assume a child can receive data from a parent via an event (rather than a property) will misread communication-pattern questions. DML questions test the imperative call pattern specifically: items reward knowing that the wire service is reactive and read-only, and that a save operation requires an explicit method call, not a wired property. Surfacing questions hinge on metadata configuration: knowing which targetConfig value maps a component to a flow screen versus a record page is the kind of precise detail these items test.
LWC covers more distinct syntax patterns than any other topic in this exam. Checking your accuracy across the full range of ITExamsTopics practice test questions for this topic, rather than focusing only on the areas you already know, is the most efficient way to find the gaps before exam day.
The question below targets a specific LWC behaviour. Read the component structure or scenario carefully before ruling options in or out.
Ready to Start Practicing?
Access all questions and start your exam preparation journey
Upgrade to Full DEX-450 Exam Questions π