CSA domain - 13% of the exam

Data Migration and Integration

Data Migration and Integration is 13% of the CSA exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

44
Practice questions
4
Objectives
16
Medium
28
Hard

Where people go wrong

  • Trusting browser-side rules to cover every write

    The wrong answers reach for a UI policy or an onSubmit client script to enforce a rule on records that also arrive through an import set, a transform or an inbound web service. Both run in the browser on a rendered form, so those routes never trigger them. A data policy or a before business rule runs on the server for every insert or update, whatever its origin, which is why either one holds across all of those paths.

    See it in a sample question
  • Expecting an after rule to change the write

    The wrong answers pick an after or async business rule to stop a save or to stamp a field on the record being saved. Both run once the database operation has happened, so an abort cannot undo it and a field they set needs a further update, which is a second write. A before rule runs while the record is still in memory ahead of the write, so aborting there blocks the insert and a field it sets is stored by that same write.

    See it in a sample question
  • Expecting an update set to carry table data

    The wrong answers treat rows of data as part of a release, or treat a table definition as something that stays behind. An update set records configuration as customer updates: dictionary entries, form layouts and business rules travel with it. Rows keyed into a table, such as reference data, are not captured, so they need an import or an XML export. Backing out a committed set likewise reverts configuration while records created in the meantime keep their values.

    See it in a sample question
  • Misjudging which update set states can be chosen or retrieved

    The wrong answers confuse the states an update set passes through. Only an in-progress set can be the current set, so completing one removes it from the picker and a later change lands in Default. Default is a catch-all that cannot be marked complete, so work held there must be moved into a new set before it can be transferred. A target instance retrieves only a Complete set.

    See it in a sample question
  • Confusing batching with merging update sets

    Batching and merging both group update sets, and the wrong answers swap their effects. Batching names a parent over child sets, so one preview and one commit apply the hierarchy in dependency order while each set stays its own record. Merging builds a single new set that keeps the latest version of each changed record, so the original sets and individual authorship no longer stay separate.

    See it in a sample question

Objectives in this domain

Sample questions from this domain

Free sampleData Migration and Integrationmedium

An administrator must ensure that the Justification field is populated whenever a request record is saved, including when records arrive through an import set or an inbound web service call rather than through a form. Which mechanism enforces the rule in all of those cases?

  • AA UI policy on the table with a mandatory action on the Justification field, applied to every view of the form.
  • BAn onSubmit client script that cancels the save when the Justification field is empty, so no record can be written without it.
  • CA data policy on the table with the Justification field marked mandatory, since data policies are evaluated on the server for any insert or update. Correct
  • DA UI policy with the Reverse if false option cleared, so the mandatory action persists once the condition has matched.
A UI policy enforces field state only in the browser, while a data policy applies the same rule on the server for every insert or update path. UI policies and their actions are delivered to the client and evaluated against the loaded form, so nothing enforces them when a record is created by an import set, a web service or another server side process. A data policy is evaluated by the platform as part of the insert or update itself, which is why it covers every entry path. A data policy can also be converted so that it applies on the form as well.

Why A is wrong: Tempting because a UI policy is the standard no-code way to make a field mandatory, but its actions run only in the browser on a loaded form, so an import or a web service insert bypasses it entirely.

Why B is wrong: Tempting because an onSubmit script does block a form save, but like a UI policy it is client side code that never executes for an import set row or a web service insert.

Why C is correct: Correct because a data policy runs server side, so the mandatory rule holds for form saves, import set loads and web service calls alike.

Why D is wrong: Tempting because clearing Reverse if false does make an action persist, but it only changes what happens when the condition stops matching on the form and adds no server side enforcement.

Free sampleData Migration and Integrationhard

A requirement states that a record must be stopped from reaching the database whenever a server-side validation fails, with the user left on the form and the record unchanged in the database. Which business rule mechanism satisfies this?

  • AAn after business rule whose script sets the abort action on the current record, which reverses the insert or update that has already been applied to the database.
  • BA before business rule whose script sets the abort action on the current record, which stops the insert or update from being applied to the database at all. Correct
  • CAn async business rule whose script sets the abort action on the current record, which cancels the insert or update once the queued scheduled job has run.
  • DA display business rule whose script sets the abort action on the current record, which blocks the insert or update while the record is being prepared for the form.
Identify the before business rule as the only timing positioned to abort an insert or update before the platform writes it to the database. Aborting depends entirely on where the rule sits relative to the write. A before rule runs while the operation is still pending, so setting the abort action prevents the database change from ever being issued. Every other timing runs once the write has been performed or is not triggered by a write at all, leaving nothing to prevent.

Why A is wrong: After rules run within the same transaction, which makes an abort sound recoverable, but the write has already happened by the time they execute and setting the abort action there does not undo it.

Why B is correct: Before rules run inside the transaction but ahead of the write, so aborting the action there means the database operation never takes place and the record is left untouched.

Why C is wrong: Async rules are server-side and can inspect the saved record, which is why this reads plausibly, but they run on a scheduled job long after the database operation has committed, so there is nothing left to abort.

Why D is wrong: Display rules do execute before anything is written, which is the surface similarity that tempts, but they are triggered by a form load rather than by a save, so they never sit in the path of an insert or update.

Free sampleData Migration and Integrationhard

An update set committed on the test instance introduced a business rule that is setting the wrong priority on incidents, and it also carried a change to an existing UI policy. During the hour it was live, users created 40 incidents with the wrong priority. The administrator uses the back out action on the committed update set. What is the outcome?

  • AThe business rule and the UI policy revert to their prior state, and the 40 incidents are reverted to their prior priority because back out reverses the whole commit.
  • BThe business rule and the UI policy revert to their prior state, while the 40 incidents keep the wrong priority because data changes were never part of the update set. Correct
  • CThe business rule is removed and the UI policy is left as committed, because back out deletes new records only and cannot restore the earlier version of an existing one.
  • DThe commit is reversed on test and on the development instance that produced it, because backing out propagates through the update source link between the two.
Predict what backing out a committed update set restores, and understand that data created while the change was live is unaffected. Back out reverses the customer updates a committed set applied on that instance: inserted configuration records are removed and updated ones are returned to the version stored before the commit. It is a configuration operation, so records created or modified by users while the faulty logic was active are untouched and must be corrected separately. It also acts locally, with no effect on the instance the set was retrieved from.

Why A is wrong: Tempting because a full reversal sounds like what back out promises, but the configuration is what was committed and the incidents were never part of the update set.

Why B is correct: Correct because back out reverses the customer updates the set committed, restoring the previous version of each configuration record, and the incident records are data that the set never captured.

Why C is wrong: Tempting because removing something new is the easier half of the operation, but back out restores the prior version of updated records as well as removing inserted ones.

Why D is wrong: Tempting because the instances are linked for retrieval, but back out acts only on the instance where the set was committed and never reaches back to the source.

Free sampleData Migration and Integrationhard

An administrator wants a set of configuration changes made on a development instance to appear in the retrieved update sets list on a test instance, using an instance to instance transfer rather than an XML file. What must be true of the update set on the development instance before the test instance can retrieve it?

  • AIt must be the current update set on the development instance, so that any late configuration change is still picked up while the retrieval is running on the target.
  • BIts state must be Complete, because only a completed update set is offered to a target instance whose update source points at the development instance and is working. Correct
  • CIt must be merged into the Default update set for its application scope, because a target instance reads only from the Default update set held on the source instance.
  • DIt must be committed on the development instance first, because a retrieval copies the committed versions of the records rather than the update set record itself.
An update set must be marked Complete before a target instance holding a configured update source can retrieve it for preview and commit. An update set stays in progress while it is capturing customer updates, and the platform will not hand a moving target to another instance. Marking it complete closes it, so no further updates are added, and the target instance reads the list of completed sets across the update source it holds for that development instance. Preview and commit then happen on the target.

Why A is wrong: Tempting because the current update set is what captures new work, but a set that is still current is in progress and is not offered for retrieval.

Why B is correct: Correct: marking a set complete closes it to further capture and makes it visible to a target instance that has a valid update source pointing at the source instance.

Why C is wrong: Tempting because the Default update set sounds authoritative, but retrieval reads completed update sets and the Default set is never a transfer vehicle.

Why D is wrong: Tempting because commit sounds like the final step, but a set is committed on the target after retrieval, not on the source before it.

Free sampleData Migration and Integrationhard

Three update sets on a development instance hold related configuration work for one project. The administrator wants all three previewed and committed on the test instance in a single operation, while each update set remains a separate record that can still be inspected on its own afterwards. Which approach meets this requirement?

  • AMerge the three update sets into a new one, which keeps only the most recent version of any duplicated update and is previewed on the target as a single flat set of changes.
  • BExport each update set to an XML file in turn and import all three files on the test instance, then preview and commit them one after another in the order they were created.
  • CMark all three complete and retrieve them on the test instance, then commit only the newest of the three, which carries the updates held in the other two along with it.
  • DBatch the update sets by naming one as the parent of the other two, so the resulting hierarchy is previewed and committed in one action while each set stays its own record. Correct
Batching links update sets into a parent and child hierarchy previewed and committed together, while merging flattens their contents into one new update set. Batching and merging solve different problems. Merging reads several sets and writes a single new set, keeping the latest version of any update that appears more than once, so the originals stop being the unit of transfer. Batching leaves the sets untouched and instead records a parent relationship, and the target instance then previews and commits the whole hierarchy in one pass in dependency order.

Why A is wrong: Tempting because merging does produce one transferable set, but the result is a flat combined set that discards older versions of duplicated updates rather than preserving three reviewable sets.

Why B is wrong: Tempting because export and import is a valid transfer route, but it produces three separate preview and commit operations rather than the single operation the requirement asks for.

Why C is wrong: Tempting because the sets are related, but retrieved update sets are independent of each other and committing one has no effect on the contents of the others.

Why D is correct: Correct: batching links update sets into a parent and child hierarchy that is previewed and committed together, and each member keeps its own identity and contents.

Other domains in this exam

See also the CSA cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by ServiceNow. Original, blueprint-aligned practice material only.