Plat-Dev-210 Salesforce Certified OmniStudio Developer Exam Topics and Questions
These Salesforce Certified OmniStudio Developer (Plat-Dev-210) 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 Plat-Dev-210 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 Certified OmniStudio Developer certification exam.
Let's Practice Free Salesforce Plat-Dev-210 Questions Aligned with Official Exam Topics
This topic establishes the platform layer: licensing, runtime models, deployment tooling, and the versioning mechanics that hold a project together. The cost shows up in environment planning, where a wrong choice about managed versus standard runtime or an incomplete permission set configuration creates rework that compounds across every component you build. β Licensing, runtimes and permission structures You need to distinguish between Managed Package Runtime and Standard Runtime, because the choice governs upgrade paths and namespace handling. Managed Package Runtime...
This topic establishes the platform layer: licensing, runtime models, deployment tooling, and the versioning mechanics that hold a project together. The cost shows up in environment planning, where a wrong choice about managed versus standard runtime or an incomplete permission set configuration creates rework that compounds across every component you build.
β Licensing, runtimes and permission structures
You need to distinguish between Managed Package Runtime and Standard Runtime, because the choice governs upgrade paths and namespace handling. Managed Package Runtime supports automatic upgrades; Standard Runtime requires manual intervention when new versions arrive. Both models have trade-offs in flexibility and control, and the exam expects you to recognise which scenario favours which approach. License requirements sit alongside this: OmniStudio uses Permission Set Licenses to gate access, and you layer Permission Sets on top to control what each user can do with FlexCards, OmniScripts, Integration Procedures, and Data Mappers. Missing a PSL or assigning the wrong permission set is a common trap.
β Tooling and deployment
The Salesforce CLI, Vlocity Build Tool, and migration utilities form the toolchain for moving OmniStudio components between environments. The exam tests your understanding of when to use each tool and how they fit into a deployment pipeline. You should know how to package a FlexCard or OmniScript for migration, what metadata types are involved, and how versioning interacts with deployment. Testing and cloning are part of the same picture: every OmniStudio component supports versioning, and you clone a component to experiment without breaking the active version.
β Requirements analysis and industry context
OmniStudio positions itself as an industry-specific platform, and the exam reflects that by asking you to map use cases in telecommunications, energy, healthcare, and the public sector to the right combination of components. A telco order capture flow has different data orchestration needs than a healthcare eligibility check, and you should be able to justify why one scenario demands an Integration Procedure while another can rely on a Data Mapper alone. Evaluating requirements means identifying assumptions, constraints, and risks: what data sources are available, what latency is acceptable, what user roles need access, and where the integration points sit.
How Omnistudio Fundamentals is tested
Eighteen percent of the exam means roughly one in five items, so expect this topic to appear early and often. Items present a scenario with stated requirements, then ask you to choose the runtime model, identify the missing permission set license, or select the correct deployment tool. The traps are subtle: a scenario might describe automatic upgrades as a requirement, and one distractor will offer Standard Runtime with a manual upgrade schedule, which sounds plausible but contradicts the need. Another common pattern is a requirements list that includes unstated constraints, such as a need for namespace isolation, and you must infer which runtime fits. Candidates lose marks by confusing Permission Set Licenses with Permission Sets, or by recommending Vlocity Build Tool when the Salesforce CLI would suffice. Read the scenario for what is required, not what is merely mentioned, and eliminate options that solve a different problem.
The practice test gives you scenario-based items across all six topics, so you can verify that you recognise licensing traps and tooling distinctions under timed conditions. The PDF version lets you review the same item pool offline, and both formats are included when you register.
The sample below turns on permission structures and the distinction between PSLs and Permission Sets in an OmniStudio environment.
Refer to the exhibit below. What is the merge code needed for this Integration Procedure structure to pass a CaseData node from the HTTP Action's output to the DataRaptor Transform Action?

FlexCards handle presentation and lightweight interaction, displaying data from multiple sources and responding to user actions without a full page refresh. The weight is moderate, but the topic punishes candidates who treat it as pure UI configuration and miss the orchestration layer: data sources, event listeners, and conditional states all demand precision. β Data sources and JSON structure FlexCards pull data from SOQL queries, Data Mappers, Integration Procedures, or custom sources, and the resulting JSON structure determines what you can...
FlexCards handle presentation and lightweight interaction, displaying data from multiple sources and responding to user actions without a full page refresh. The weight is moderate, but the topic punishes candidates who treat it as pure UI configuration and miss the orchestration layer: data sources, event listeners, and conditional states all demand precision.
β Data sources and JSON structure
FlexCards pull data from SOQL queries, Data Mappers, Integration Procedures, or custom sources, and the resulting JSON structure determines what you can bind to card elements. You configure the data source in the FlexCard designer, test the output, and adjust the query or procedure until the shape matches what your layout needs. The exam expects you to recognise when a SOQL query is sufficient (simple, single-object retrieval with minimal transformation) and when you need a Data Mapper or Integration Procedure (multi-object orchestration, external callouts, or complex transformation). A common mistake is choosing a data source that returns nested arrays when the card layout expects a flat structure, or vice versa.
β Layouts, actions and interactivity
Single-level FlexCards display one record; multi-level cards use parent-child relationships to show related data in a repeater or nested layout. You bind fields to card elements (text blocks, images, buttons) and configure properties like visibility, styling, and default values. Actions are where FlexCards move beyond display: you can launch an OmniScript, fire an event that another component listens for, update session variables, or refresh a child FlexCard. The exam tests your ability to chain actions correctly. Launching an OmniScript requires passing context data, and firing an event means another component must subscribe to that event name. Public attributes let you pass data into a FlexCard from a parent component, and event listeners let the card respond to external changes. Session variables persist across components in the same session, so you use them to share state without requerying.
β Styling, states and embedding
Conditional rendering uses states to show, hide, or alter elements based on data values or user actions. You define a state condition (such as account status equals active), then specify which elements appear in that state. Styling applies at the theme level or per element, and the exam distinguishes between global theme changes and inline overrides. Embedding FlexCards means placing them in Lightning pages, Experience Cloud sites, or inside OmniScripts, and each channel has constraints on available actions and data context. Best practices cover performance (avoid redundant data sources), maintainability (use states instead of duplicate cards), and reusability (design cards that accept public attributes so they work in multiple contexts).
How Flexcards is tested
Fifteen percent translates to roughly one in seven items, concentrated on data source selection and action configuration. A typical item describes a requirement (display account details and related cases, with a button to create a new case) and asks which combination of data source, layout, and action satisfies it. The distractors will include plausible but incomplete solutions: a SOQL query that retrieves accounts but not cases, or an action that launches an OmniScript without passing the account ID. Conditional states appear in items that specify different layouts for different record types, and you must choose the state logic that matches the requirement. Candidates lose marks by selecting a Data Mapper when a simpler SOQL query would work, or by configuring an event that no other component listens for. The exam rewards specificity: if the requirement says the card must update when another component changes a session variable, the correct answer involves an event listener, not a static data source.
A full question bank lets you see how FlexCard scenarios vary in complexity, from single-source layouts to multi-level cards with event-driven updates. Practising the range shows you which data source and action combinations the exam favours, so you spend less time second-guessing during the real attempt.
The sample that follows asks you to select the correct data source and action configuration for a FlexCard that displays and updates related records.
Which two fields in an Integration Procedure can use a function like CONCAT or DATEDIFF?
Choose 2 answers
OmniScripts orchestrate multi-step processes, capturing input and moving data through a sequence of screens and actions. At twenty per cent this is the heaviest single topic, and it costs candidates who conflate OmniScript elements with FlexCard components or who ignore the dataJSON structure that ties everything together. β Elements, child components and interactivity OmniScript elements fall into three categories: input elements (text, number, date, picklist, checkbox), group elements (step, block, type-ahead block), and action elements (button, navigation, set Values). You...
OmniScripts orchestrate multi-step processes, capturing input and moving data through a sequence of screens and actions. At twenty percent this is the heaviest single topic, and it costs candidates who conflate OmniScript elements with FlexCard components or who ignore the dataJSON structure that ties everything together.
β Elements, child components and interactivity
OmniScript elements fall into three categories: input elements (text, number, date, picklist, checkbox), group elements (step, block, type-ahead block), and action elements (button, navigation, set Values). You assemble these into a flow that collects data, validates it, and triggers downstream processes. Dynamic interactions mean showing or hiding elements based on earlier input, using conditional views or response actions. Child OmniScripts let you embed one script inside another, reusing a common sub-process without duplication. FlexCards embedded in an OmniScript can display related data or summary information, and custom Lightning Web Components extend the UI when standard elements do not fit the requirement. The exam expects you to choose the right element type for each input, recognise when a child OmniScript simplifies maintenance, and know how to pass data between parent and child.
β Styling, properties and embedding
Styling applies via themes or inline overrides, and advanced properties control behaviour that is not visible in the basic element configuration. Multi-language support lets you define labels and messages in multiple locales, switching based on user language. Save options determine whether the script saves data to Salesforce objects as the user progresses (step-by-step save) or only at the end (save on completion). The messaging framework provides user feedback (success, error, warning messages) without custom code. Knowledge articles can be surfaced inline when the user needs help. Embedding OmniScripts works the same way as FlexCards: Lightning pages, Experience Cloud, or inside another OmniScript. Each channel has different constraints on navigation and save behaviour. Best practices emphasise keeping scripts short (under ten steps where possible), avoiding redundant data queries, and using Set Values elements to prepare data for downstream actions instead of embedding logic in Integration Procedures.
How Omniscripts is tested
Twenty percent means one in five items, and the exam spreads them across element selection, conditional logic, and embedding scenarios. A typical item gives you a process requirement (collect customer details, validate eligibility, create a case) and asks which combination of elements and actions satisfies it. The distractors include plausible but inefficient solutions: querying the same data twice, using a custom LWC when a standard input element would work, or embedding a child OmniScript that does not return the required data to the parent. Conditional views appear in items where the script must adapt based on user role or earlier input, and you must select the correct element property or response action. Candidates lose marks by choosing a Set Values action when a DataRaptor (Data Mapper) Extract is required, or by embedding an OmniScript in a channel that does not support the required save behaviour. The exam rewards clarity: if the requirement specifies step-by-step save, the correct answer will configure that property explicitly, and the distractors will omit it or set it incorrectly.
Practising with a full question bank shows you how the exam varies element combinations and how often conditional logic appears in OmniScript items. Seeing the patterns under timed conditions means you recognise the efficient solution faster, which matters when twenty percent of the exam depends on this topic.
The sample below presents a multi-step process requirement and asks you to identify the correct combination of OmniScript elements and properties to satisfy it.
Integration Procedures orchestrate server-side logic, calling external systems, transforming data, and coordinating multiple operations in a single transaction. Fifteen per cent makes this a mid-weight topic, but it has the steepest learning curve because every action type has specific input and output requirements, and the exam tests your ability to chain them without losing data or breaking the execution path. β Actions, logic and execution control You build an Integration Procedure by dragging actions into a canvas and connecting them...
Integration Procedures orchestrate server-side logic, calling external systems, transforming data, and coordinating multiple operations in a single transaction. Fifteen percent makes this a mid-weight topic, but it has the steepest learning curve because every action type has specific input and output requirements, and the exam tests your ability to chain them without losing data or breaking the execution path.
β Actions, logic and execution control
You build an Integration Procedure by dragging actions into a canvas and connecting them in sequence. Data Mapper actions (Extract, Transform, Load) retrieve and shape data from Salesforce or prepare it for external systems. Standard actions include Remote Actions (call an external API), HTTP Actions (direct HTTP requests), Response Actions (return data to the caller), and sub-Integration Procedures (call another IP). Conditional logic uses decision elements to branch based on data values, and loops iterate over arrays. The exam expects you to choose the right action type for each step and configure its inputs correctly. A common mistake is using a Remote Action when an HTTP Action is required, or forgetting to map the output of one action to the input of the next. Try/Catch blocks wrap actions that might fail, letting you handle exceptions and roll back changes instead of leaving partial updates.
β Performance, caching and best practices
Chainable Integration Procedures split a long-running process into multiple transactions, each committing independently. You use this when a single transaction would exceed governor limits or when you need to return a response before all processing completes. Caching stores the output of an action so subsequent calls return the cached result instead of re-executing, which improves performance but introduces staleness risk. The exam tests your ability to recognise when caching is safe (reference data that changes infrequently) and when it is not (transactional data that must be current). Response Actions define what data the IP returns to the caller, and you configure them to return only the fields the caller needs, not the entire intermediate JSON. Best practices emphasise keeping IPs focused (one IP per logical operation), avoiding nested loops, and using sub-IPs to promote reusability.
How Integration Procedures is tested
Fifteen percent means roughly one in seven items, and they concentrate on action selection, error handling, and performance optimisation. A typical item describes a requirement (retrieve account data, call an external API to validate it, then create a case if validation succeeds) and asks which sequence of actions satisfies it. The distractors include incomplete sequences (missing the Response Action, so the caller receives no data) or incorrect error handling (no Try/Catch block, so a failed API call breaks the entire script). Caching appears in items that specify performance constraints, and you must decide whether to cache the Extract action, the Remote Action, or neither. Chainable IPs appear in scenarios with long-running processes, and you must recognise when splitting transactions is required versus when it introduces unnecessary complexity. Candidates lose marks by choosing a Data Mapper Load when a standard DML action would work, or by configuring a Response Action that returns the entire dataJSON instead of the specific fields requested. The exam rewards precision: the correct answer matches the requirement exactly, and the distractors either do too much or too little.
A question bank with full coverage of Integration Procedure scenarios lets you practise action sequencing and error handling until the correct pattern is automatic. The volume matters because each action type has distinct configuration requirements, and repetition is what makes those distinctions stick.
The sample below gives you a server-side orchestration requirement and asks you to select the correct sequence of Integration Procedure actions and error handling to meet it.
Data Mappers extract, transform, and load data between Salesforce objects, external systems, and document formats. At seventeen per cent this is the second-heaviest topic, and it punishes candidates who treat it as a simple field-mapping exercise and miss the formula logic, interface type selection, and output structure requirements that determine whether the downstream component receives usable data. β Interface types and data retrieval Extract retrieves data from multiple objects with filter conditions, related lists, and field selection, returning a JSON...
Data Mappers extract, transform, and load data between Salesforce objects, external systems, and document formats. At seventeen percent this is the second-heaviest topic, and it punishes candidates who treat it as a simple field-mapping exercise and miss the formula logic, interface type selection, and output structure requirements that determine whether the downstream component receives usable data.
β Interface types and data retrieval
Extract retrieves data from multiple objects with filter conditions, related lists, and field selection, returning a JSON structure you configure. Turbo Extract is optimised for single-object queries with related fields, offering better performance but less flexibility. The exam expects you to choose Turbo Extract when the requirement involves one object and its children, and standard Extract when you need to query unrelated objects or apply complex filters. Both interfaces let you configure formulas to manipulate field values during extraction, such as concatenating first and last name or converting a date to a different format.
β Transformation and loading
Transform prepares data for downstream use, reshaping JSON for an Integration Procedure or formatting it for document generation (PDF, DocuSign). You map source fields to target fields, apply formulas to create calculated values, and structure nested objects to match the expected output. Load writes data to one or more Salesforce objects, and you configure it to insert, update, or upsert records based on a key field. The exam tests your ability to match the interface type to the requirement: use Transform when the output is JSON or a document, and Load when the output is Salesforce records. A common mistake is choosing Load when the downstream component expects JSON, or Transform when the requirement specifies creating records.
β Formulas, mapping and best practices
Formulas in Data Mappers use a syntax similar to Salesforce formula fields, supporting concatenation, arithmetic, date functions, and conditional logic. You apply formulas in Extract, Transform, and Load interfaces to create or modify values without custom code. Mapping source to target means dragging fields from the input structure to the output structure, and the exam expects you to recognise when a direct mapping is sufficient and when you need a formula to bridge the gap. Best practices emphasise designing Data Mappers for reusability (parameterise filter values so the same mapper works in multiple contexts), avoiding redundant queries (use Turbo Extract when possible), and testing output structure before embedding the mapper in a FlexCard or Integration Procedure.
How Data Mappers is tested
Seventeen percent means roughly one in six items, concentrated on interface selection and formula configuration. A typical item describes a data requirement (extract account and contact details, concatenate address fields, return JSON for a FlexCard) and asks which Data Mapper interface and formula combination satisfies it. The distractors include plausible but incorrect choices: using Load when the output should be JSON, or selecting standard Extract when Turbo Extract would work and perform better. Formula items give you a transformation requirement (format a phone number, calculate a date difference) and ask which formula syntax produces the correct output. Mapping items show a source structure and a target structure, then ask which fields must be mapped or transformed to achieve the target. Candidates lose marks by choosing Transform when Load is required, or by writing a formula that produces the wrong data type (text instead of number, or vice versa). The exam rewards specificity: if the requirement says the output must be a PDF, the correct answer uses Transform with PDF as the output type, and the distractors will use JSON or Salesforce objects.
Practising with a full bank lets you see how interface type and formula requirements vary across scenarios, so you recognise the correct Data Mapper configuration without re-reading the documentation. The demo version lets you verify the question style before committing.
The sample that follows describes a data extraction and transformation requirement, then asks you to select the correct Data Mapper interface type and formula configuration.
This topic tests your ability to diagnose and fix failures across all OmniStudio components. Fifteen per cent means roughly one in seven items, and they assume you already know how FlexCards, OmniScripts, Integration Procedures, and Data Mappers work. The exam presents a symptom and asks you to identify the root cause and the correct fix. β Component-specific failures FlexCard display issues usually trace to incorrect data source configuration (the JSON structure does not match what the layout expects) or state...
This topic tests your ability to diagnose and fix failures across all OmniStudio components. Fifteen percent means roughly one in seven items, and they assume you already know how FlexCards, OmniScripts, Integration Procedures, and Data Mappers work. The exam presents a symptom and asks you to identify the root cause and the correct fix.
β Component-specific failures
FlexCard display issues usually trace to incorrect data source configuration (the JSON structure does not match what the layout expects) or state logic that hides elements unintentionally. OmniScript errors fall into two categories: execution errors (a required field is missing, a DataRaptor call fails) and rendering errors (an element does not appear, or the script stops mid-flow). Data Mapper output problems mean the returned JSON is malformed, missing fields, or has the wrong structure, often because a formula returns null or a mapping is incomplete. Integration Procedure execution errors include failed Remote Actions (the external system returned an error), missing input parameters (an action expects a field that was not passed), or unhandled exceptions (no Try/Catch block, so the IP stops on the first failure). The exam expects you to match the symptom to the component and the likely cause.
β Cross-cutting issues and tooling
Caching problems appear when a component displays stale data because the cached result has not been invalidated. You fix this by adjusting cache scope or time-to-live, or by disabling caching for data that changes frequently. Permission and access issues mean a user cannot see a FlexCard, launch an OmniScript, or execute an Integration Procedure, usually because the required Permission Set or Permission Set License is missing. JSON errors (missing brackets, incorrect nesting, unexpected null values) break components that depend on that structure, and you fix them by inspecting the JSON output in the Debug Console or the component preview. Publishing and deployment issues include components that work in one environment but fail in another, often because a dependency (a custom field, a Remote Action configuration, a Data Mapper) was not migrated. The Debug Console is the primary diagnostic tool: it logs each action in an Integration Procedure or OmniScript, shows input and output JSON, and highlights errors with stack traces.
How Troubleshooting and Debugging is tested
Fifteen percent means roughly one in seven items, and they present a failure scenario with symptoms, then ask you to identify the root cause or select the correct fix. A typical item describes a user complaint (a FlexCard shows no data, an OmniScript stops at step three, an Integration Procedure returns an error) and provides diagnostic information (Debug Console logs, JSON output, error messages). You must match the symptom to the cause: a FlexCard with no data usually means the data source returned an empty array or the wrong structure, and the fix is to adjust the query or the card layout. An OmniScript that stops mid-flow often means a required field is missing or a DataRaptor call failed, and the fix is to check the dataJSON and the action configuration. Candidates lose marks by choosing a fix that addresses a symptom without solving the root cause (refreshing a FlexCard when the real problem is a missing permission), or by selecting a cause that does not match the diagnostic evidence (blaming a formula error when the Debug Console shows a failed Remote Action). The exam rewards methodical diagnosis: read the logs, identify the failing action, check its inputs and outputs, then choose the fix that corrects the configuration.
A question bank with troubleshooting scenarios shows you how the exam presents diagnostic information and what patterns of failure appear most often. Working through these under timed conditions trains you to spot the root cause quickly, which saves time when fifteen percent of the exam depends on accurate diagnosis.
The sample below presents a component failure with diagnostic logs and asks you to identify the root cause and the correct fix.
Ready to Start Practicing?
Access all questions and start your exam preparation journey
Upgrade to Full Plat-Dev-210 Exam Questions π