An update set suits configuration changes made in the global scope, while the application repository suits scoped applications. For any single app, pick one transfer path and stick to it, because mixing update sets and repository transfers for the same app is a common source of release problems.
This page compares the two methods by app type, explains what each one carries, and sets out rules for hotfixes, version checks and back-outs. The parent guide on update sets and release management covers the wider release process around them.
An update set records edits as they happen, while a repository packages the whole app
An update set is a named container. While it is the active set on your development instance, configuration changes you make are recorded into it. You then export that set as XML, or move it through the instance’s transfer steps, and load it on the target. It is a record of edits, not a snapshot of an application.
The application repository works at the level of the app. You package a scoped application with its version and the components it depends on, then move that package between instances. Because the unit is the app, the target receives one thing rather than a list of edits. Store apps follow a similar idea, with the store handling distribution, though the exact steps depend on the plugin and its version.
Comparison by app type: scoped, global and store apps
The table is a starting point. Behavior differs between releases and between plugins, so verify each cell on your own instance.
| Situation | Update set | Application repository | Git source control |
|---|---|---|---|
| Scoped custom app | Captures many edits, but some are easy to miss | Moves the app as one package | Keeps history and a review trail, once connected |
| Global configuration with no app | The usual choice | Not applicable | Rarely used |
| Store app and your customizations | Customizations can be captured, but check overlap with the store version | The store installs the app; keep your changes separate | Works for your own customizations if you track them |
Git source control fits best when a team already works in a repository and wants commits, reviews and history to be the record of what changed. It replaces the question of which update set held a change with the question of which commit did. The DevOps and source control guide covers how that pipeline is usually wired.
Entitlements decide which instances can install a published app
By default, all instances in your company are entitled to an app you publish to the application repository, so each one can install it. To limit that, change the entitlement type for the app in the repository. An instance that has lost its entitlement can be entitled again later, so a removal is not permanent.
Entitlement is a permission to install, not a copy of the package. An instance without it cannot install the app even though the package sits in the repository, which can explain why one instance fails a release that another installs without trouble. Check entitlements first when that happens. Self-hosted and air-gapped customers do not install it from the public store; they arrange a separate setup with ServiceNow instead.
What each method carries, and what it can leave behind
An update set only carries what was recorded while it was active. If a developer switches the active set partway through a task, part of the work lands in a different container, and the target receives an incomplete change. Check the active set before each edit and review the contents before export. The usual symptom is a feature that works on the source and fails on the target because one piece did not arrive. Our notes on fixing update set problems after a failed load walk through those checks in order.
Mixing the two for one app is the real trap. If some components travel in an update set and the rest in a repository package, the target can end up with two sources of truth for the same app. It then becomes hard to say which version is live. Choose one path for each scoped app. If you are still building the app, the custom application development work is the build side of the same decision, and the rule above applies whichever team does it.
Some changes do not reach the target through an update set
Read the contents of an update set before you export it. Pay particular attention to deletions: a table you remove from the source is flagged when it still holds data, and restoring that table does not bring its data back.
Read the Update Set Preview Problems list before you commit. It flags missing objects, collisions, uncommitted updates and conflicts within a batch, and each problem has a stated way to resolve it, such as skipping the remote update or accepting it.
An app that lives in the repository should stay there
Once you have installed an application from the repository, it is simplest to keep later development on the same route. Teams that try to carry on the same app with update sets tend to hit skipped changes and commit errors, so settle the route at the first install.
Interim builds are worth publishing deliberately rather than on each commit, because each published version is a candidate for a later back-out.
Hotfixes and version alignment before any transfer
A production hotfix is a common way a release plan breaks. If someone fixes a problem directly in production, the next transfer from development brings back the old behavior. Rebuild the fix in development, test it there, and transfer it through the normal path. Then confirm production matches the rebuilt version. Treat the production edit as an emergency measure that has to be repeated in development before the next release.
Version alignment matters before any transfer. Check the source and target release versions, along with the versions of any plugin the app depends on. Changes built on a newer release can rely on behavior an older instance does not have. If the two versions differ, test the transfer on a non-production instance first.
Back-out options and rules of thumb for each situation
Back-out works differently for each method. Where your version offers a back-out for an update set, use it, but do not rely on it for changes that touched data. For a repository package, keep the previous version of the app available before the transfer so that a back-out has a version to return to. Plan the back-out before the transfer, not after the target breaks. Once a release is live, the application management work that keeps it stable is a separate concern from the transfer itself.
- Global configuration with no app: use an update set, and keep each set to one logical change.
- Scoped app with no source control: use the application repository and one transfer path only.
- Scoped app already in Git: treat the repository as the record and avoid update sets for that app.
- Any production hotfix: rebuild it in development before the next transfer.
Frequently asked questions
Can I move a scoped app with an update set?
You can capture some of its changes in an update set, but an update set is not a reliable package for a whole scoped app. Use the application repository or source control for the app itself, and keep update sets for global configuration.
Should I use Git source control instead of the application repository?
Use the option your instance and team already support. Git gives you history, reviews and branches. The application repository gives you a simpler packaged move. Whichever you choose, make it the only path for that app.
What if a hotfix was made directly in production?
Rebuild the same change in development, test it, and transfer it through the normal path before the next release. Then compare production with the rebuilt version so the two match.