Description
AI is helping Salesforce teams build changes faster, but deploying those changes with change sets hasn’t sped up. The result is a longer queue, more manual rebuilds, and more chances for a missed dependency to break production.
In this webinar, Maroof Abdul-Aziz, Customer Onboarding Manager at Gearset, walks through seven of the most common change set problems and the process changes that make each one less painful, then shows the same deployment in Gearset Compare & Deploy.
What you’ll learn:
- How to keep sandboxes in line with production through regular refreshes and back-promotion, so you’re not building and testing against an out-of-date org.
- Why the View/Add Dependencies button is a starting point rather than a safety net, and how to trim its suggestions so older sandbox versions don’t overwrite newer ones in production.
- How to keep a shared tracker of components, manual steps, and changes change sets can’t move, like standard picklist values and CPQ pricing rules, so nothing gets forgotten on release day.
- What validation can’t catch, from hard-coded record type IDs in flows to profiles that land differently than expected, and how Quick Deploy lets you validate early and deploy in your release window.
- How to prepare for a release with no rollback option, and how Compare & Deploy handles missing dependencies, precision deployments, and rollbacks from a pre-deployment snapshot.
Learn more
- Gearset’s Compare & Deploy solution
- The State of Salesforce DevOps 2026
- The hidden cost of change sets
- Salesforce deployment best practices
- How Ninety One transformed Salesforce release management and made deployments 5–10x faster with Gearset
Relevant videos
Transcript
Awesome, folks. Cool. Well, let's get going. So today, we're here to talk about change sets.
Now change sets have been around for a long time. They're free. They're built into every org. And for small teams shipping a handful of changes in a sprint, they do the job.
But most people who use them have experienced deployments that didn't quite go to plan. Maybe you've uploaded a change set, then realize you missed a field, so you have to clone it and upload it again. Or a deployment fails because of a dependency you didn't know about. Or everything deploys fine, but the next morning, someone can't see a page layout they were using the day before.
And if you go from a developer sandbox to a UAT or staging and then to production, you're rebuilding the change set for every environment, and each stage is another chance for human error. For many teams, this method of deploying changes has...
Hasn't caught up with the way Salesforce professionals are now working. At the start of 2026, Gearset's state of Salesforce DevOps report found 84% of teams were using AI to build their Salesforce changes. And no doubt since then, that percentage has probably increased. At the very least, teams are using AI to write Apex and test classes, build out flows, work through problems, and many teams are doing much more than that.
Either way, it means a lot more changes are now waiting to be deployed. When building gets quicker but the deployment process stays the same, the queue to deploy just gets longer. Today, we're gonna talk through seven of the most common issues people come across when using change sets and how to guard against them to minimize the likelihood of a deployment going wrong. Obviously, there isn't much you can do about how change sets work.
The interface is what it is. And short of moving to a different tool, you'll be working within its limits for as long as you use them. What you can change is your process. The checks you run, the notes you keep, and the way you communicate with your team, none of that completely removes the challenges of change sets, but it does make deployments less painful and more likely to succeed.
So let's dive straight in. The first issue that affects teams before they even get started is alignment. Most teams will work in sandboxes before deploying, but sandboxes easily drift from production. Production picks up changes like hot fixes or a change someone added directly, and these don't make it back to the sandbox automatically.
So in turn, you will end up building and testing against an org that's out of date. Now several people are building at once with their own sandboxes. Not only are you out of sync with production, but now with each other's changes too. This makes deployments more likely to fail or for you folks to overwrite something.
So to guard against this, you can regularly refresh your sandbox. Keep them as close to production as possible. Developer sandboxes are quick to refresh, and you can do it daily. So refresh before each new piece of work.
Now this advice extends to partial copy and full full sandboxes. Although the limit means that you can only refresh, say, five to twenty nine days, and these can take anywhere from hours to days. So plan ahead for these refreshes, for example, after a big release. Some best practice here includes, like, before a refresh, writing down what you'll need to reset afterwards.
Pick a time when nobody needs the sandbox, and tell everyone who uses it that a refresh is scheduled. If, for example, you have work in progress or a refresh isn't an option, then you want to back promote. Move the changes made in production back down to your sandboxes so they stay close to what's live. And a final note and a final note on this is to beware of building in a new sandbox without authorizing the deployment connection.
Check deployment settings in your target org before you start building to save time later. Once you're ready to start building your change set, you're likely to hit the next issue. There's no way to see what you've modified since you started the work. You have to add each component by hand and remember what components were covered in the build stage.
Perhaps it's a few objects, a flow, a couple of classes. But if you miss something, you'll find out when the deployment fails or when it succeeds but breaks a feature in production. If more than one person is building, you might each change the same component in a different sandbox and put the different...
Like, put them in across different change sets. Now whichever one gets deployed last wins, and the person's work is overwritten in production. Now there's no way...
No easy way to see that overlap. So how do you guard against this? Well, there's not much you can do about the UI, but it's a really good idea to keep a record of your changes as you go rather than relying on memory. Every component you create or change goes on a list with the type, whether it's new or changed, and the manual steps it needs when you when you deploy.
You could use a shared spreadsheet or as a tracker, or if your team uses a board like Jira or Asana, add a components change checklist to each card. If more than one person builds, make that record shared. List every component that's in progress and who's working on it. And when two people need the same flow or object, they find out while they're building rather than after they deploy.
And finally, give the release manager the tracker alongside the change set so you...
So they too can see what's in each one. They can spot overlaps before anything goes to production, and keep a line of communication across the entire team because no tracker can catch everything. And if you've already started building and not being keeping track, you can also use the setup audit trail in your sandbox. This shows the setup changes made over the last six months, and it's downloadable as a CSV.
Now it doesn't track every kind of change, but it's better than nothing. Next, we have missed dependencies. Missed dependencies are one of the biggest reasons change set fails. The manual overhead of figuring them out is a big reason behind deployment bottlenecks.
Once you've added your components, the dependency tool for the metadata they reference, for example, if you add a page layout, it might identify custom fields that the layout displays. The dependency tool catches direct relationships reasonably well, but it struggles with indirect dependencies, like the chain of references that are common in complex configurations. A flow might reference a record type which depends on a picklist value, which uses a global value set. The dependency tools...
The dependency tool will only surface the first link. It can...
It also can't distinguish between dependencies that already exist in your target org and those that are genuinely new. Selecting everything it suggests can blow your change set with hundreds of components. More components in the change set means a higher chance of a component can't deploy successfully. And in some cases, older sandbox versions overwrite new ones in production.
If someone changed a field in production last month, and your sandbox still has the old version, ticking everything can send the old version right back. To guard against this, treat the View/Add Dependencies button as a starting point rather than a safety net. Review the list and remove components that already exist in production, then verify what remains, then verify what remains and needs to be deployed. And when you find a dependency, write it down, what it was, how you resolved it, and share it with the team.
It will save time on your next release. What you can't do with native tools is see full comparisons of tools. Checks and notes narrow the gap, but they won't quite close it. Another issue teams face is once you upload a change set, you can't edit it.
You can't add a missing component or take out something you included by mistake. The only way forward is to clone it in the source, fix the clone, upload it again, validate it again, and the original stays in the target org's inbound list until it's deployed or someone goes ahead and removes it. Now you end up doing that a few times, and you start to get a list that looks a bit like this. There's no built in cleanup, so old versions start to pile up.
For release manager looking at inbound change sets from several people, a list that is...
A list like that can easily lead to mistakes. For example, deploying version two when version three was the one that passed the testing. Now you can't change...
Stop change sets from locking, but you can keep the list readable. Name every change set so you will recognize it in three weeks' time. Week 49 release could mean anything, whereas account territory fields November 2026 tells you exactly what's inside. Agree on a naming convention that works for your team and make sure everyone sticks to it.
Use a description field for the ticket number. The...
Use a description field to input your ticket number, the version, and a one line summary of the change. And when a version is replaced, remove the old one from the inbound list to keep things legible. And in your shared tracker, keep a note of which change set went to production and when, making it easier for the team. Now the next issue is all around validation.
Validation runs validation runs through a deployment without committing anything. It checks for things like missing dependencies, and for production, it runs your Apex tests. So it's worth doing every time because it catches the errors that would have made a deployment fail. However, validations can't tell you whether the change works.
A flow with a hard coded ID will pass validation and then fail in production because that ID doesn't exist there. A record type created in a sandbox gets a different ID when it's deployed to production, so this one catches a lot of people. Permissions are another problem. If you...
If your change set includes profiles, they can pass validation but not land the way you'd expect, so users can end up unable to do something they they could do yesterday. And validation is a snapshot. If someone changes a field or deletes an object in production between your validation and your deployment, the deployment could fail anyway. So what can you do about it?
Well, first, you should test the business process as well as the deployment. Run the change through every scenario in a sandbox, including the awkward ones. Imagine a user cancels halfway through a flow or it times out. That way, the people who will use it get to try it in UAT.
Second, don't hard code IDs in your flows. Refer to record types by their developer name, which stays the same in every org, or stores value like that in custom metadata or a custom label. Third, Salesforce's own advice is that profiles as a change set...
Profiles in change sets are for giving people access to new functionality, not for updating what's already in production. So try and keep profiles light and manage access through permission sets instead. If you do need to send a profile, send the record type and the page layout it relies on with it. And finally, after a successful validation, quick deploy lets you deploy within ten days without running the tests again.
So you can validate a quiet time and deploy in your release window. Team communication is key here as you want to ensure others don't change anything between validations and deployments so the validation still holds. Another issue is not everything can go through a change set. Some metadata types aren't supported by metadata API, and others that are supported by the API but don't appear in the change change set interface.
Changes to standard picklist, like adding a value to opportunity stage, they don't deploy. Neither do organization wide email addresses, some territory management settings, or some Experience Cloud components. Change sets only move metadata, so anything in your org store...
Anything your org stores as data won't go through. Now this can include a lot of configuration, like CPQ pricing rules, which then has to be moved separately. Flows also have their own quirks. An active flow in a change set arrives in the target org as inactive, so some people have to activate it after deployment.
Now there's a setting in production, in your production's process automation settings that lets flows deploy as active, but it comes with test coverage requirements. So check with your team before you rely on that. Now you can't make change sets move things, but you can make sure they don't get forgotten. For example, bookmark Salesforce lists of supported metadata types and check it when you plan a release.
Anything that can't go into a change set, like unsupported metadata or CPQ pricing rules, or anything that needs doing after a deployment, like activating a flow, for example, should go on your deployment checklist as a manual step and record who's doing it and when. And if a release manager deploys, the manual steps needs to travel with the change set because the person deploying may not be the person who built it. And finally, here's the issue that really ruins your week. Change sets don't have a rollback.
Once deployment completes, it's committed to production. If something breaks, some team...
Some teams reverse the changes by hand in production, which means editing your live org under pressure. That's risky and really easy to get wrong. Others redeploy old versions from a sandbox that still has them in a in a new change set, but that only works for things you've changed, though. Change sets can't deploy deletions, so anything that's new has to be removed by hand.
Either way, you need to know what production looked like before the deployment and the change sets. This way, you can keep a snapshot, and without your notes, putting it all back is all guesswork. And finally, you can't bring back lost data without a backup or restore tool. So if a change wipes the value in a field, a change set can't restore them.
This is probably the hardest one to guard against. There's no way to add a real rollback, so all you can do is prepare. Before you deploy, get a picture of the current state of anything you're about to change, especially profiles, existing flows, validation rules. Even screenshots are better than nothing.
On deployment day, refresh a spare developer sandbox if you can from production so you've got an old version to redeploy if you need them. Try choosing your deployment slots with recovery in mind, a quiet time to minimize impacts, but with a few hours afterwards so you can watch what happens. Tell the people affected when you're deploying and what's in it, so if something goes wrong, they know who to talk to. And if something breaks, switching off the broken flow or validation rule, reactivate reactivating the previous version of the flow, you can buy some time while you work out a proper fix for this.
And it goes without saying that you should make sure your actual data is backed up. None of this is a real rollback, though. It's a lot of manual work, and it relies on you guessing what might go wrong before it does. If your team needs to roll back more than once in a while, then you should probably look at a tool that makes sure that your record of production is being snapshotted so that you can restore it.
So here's a summary of what we've covered and the precautions you can take to give each deployment a better chance of success. They'll help you avoid failed deployments and time lost to rebuilding failed change sets. However, they're unlikely to make deployments fast enough to keep pace with AI built changes. No matter how careful you are, there's a point where change sets just can't keep up.
That's why a lot of teams have moved away from change sets and have handed their manual work to tools that do it for them. So with that in mind, in the remaining time, I'd like to briefly show you what a deployment looks like in Gearset. Gearset's Compare & Deploy allows you to select a source and a target, compare the differences between them, and deploy the changes you need. Today, we're gonna focus on an org to org deployment, but Gearset also supports Git repositories, scratch orgs, and local files.
So let's go ahead and pick my developer environment and UAT. So I'm ready. I'm gonna start an instant comparison. Now one of the challenges with Salesforce deployments is find...
Is finding the changes you actually want to deploy amongst hundreds of differences between environments. Now this is where the metadata filter comes in. On the left hand side over here, you'll see Gearset's...
Gearset lets us narrow down the comparison to a specific type of metadata we're interested in. Now I regularly like to use with saved comparison filters. These will include the components that I most regularly work with. And if there's something else that I need to add for a particular deployment, I can easily search for it and add it to my comparison.
So today, I'm gonna bring in a flow. If I want to expand my search further, I can browse all the metadata types Gearset supports, including Revenue Cloud components. And for those of you building on Agentforce, also Data 360. Let me just head back to my deployment for it to load.
Once I've selected my filter, Gearset will start to retrieve the relevant components and present the results here. In the top half of the screen, I can see the components that Gearset has retrieved. And when I select one, in the bottom half, it's showing me how it appears in my source, so my developer environment, and in my target, UAT. This makes it much easier for me to start to kind of understand what's happening across the two orgs.
To break these results down even further, I can use these toggles here to search what's new, which will show me items that exist in my source, not my target. Changed, this will show me items that exist in both, but there are differences. And finally, deleted, this will show me items that exist in my target, so in UAT, but not in my developer sandbox. And something worth highlighting here is that unlike change sets, Gearset also allows us to make destructive changes so we can remove components we no longer need.
Okay. So let's start building out my deployment. So for today, the example that I'd like to use is a discount rate custom field. So I'll be able to go ahead and find that from my changes.
Here it is right there. I'm gonna go ahead and select it. And you will see if I click into this chevron, it opens up a bunch of dependencies used by profiles and permissions. Gearset is flagging to me all these dependencies.
It's also showing me the layouts that this...
That that will be surfaced with this component. And any additional profiles and permissions are also being shown to me right here. This gives me the visibility that I need to go ahead and start to pick these up. Now human error can happen at any moment.
So what you'll see here is I'm gonna go ahead and choose to ignore these. Well, the first thing Gearset's gonna do is it's gonna give me some suggestions in this bottom left hand corner. So if I click into here, you'll see it's telling me to bring in the relevant permission set. It's telling me to bring in another custom custom field that it relies on, and it's also telling me why.
For today's example, I'm going to choose to ignore Gearset because I'd like to show you how Gearset goes ahead...
To handle this for you. While we are here, I do wanna show you a couple of other tips that can help teams that are working together. So especially when teams work together in a shared sandbox, one of the biggest challenges is accidentally deploying somebody else's work. For example, imagine you and a colleague have both been working on the same page layout.
You might only want to deploy your changes without overwriting the work your colleague has been doing. Now this is where a precision deployment becomes really useful. If I pick out an example of this, you'll see that. So let me go ahead head to layout and pick one here.
So rather than deploying the entire component, Gearset let...
Gearset lets me select specific changes that I want to include. Now this means I can keep my deployment focused on the feat...
On my feature without bringing across the unrelated changes that a colleague of mine might be working on, and I can granularly select here. And for those of you working with Salesforce flows, Gearset also makes it much easier to review. So if I head in and search for a flow, let me show you what that is. So Gearset presents the flow in a visual interface that mirrors what you're familiar with in Salesforce Flow Builder rather than having to un...
Interpret underlying XML. You can also choose which version of the flow you'd like to deploy, again, making it much easier to understand what's changed before you deploy it, including individual components to kind of see at a very granular level how this flow is being impacted. Awesome. So now that I'm happy with the package that I've selected so far, I'm gonna go ahead and click next.
Now remember earlier when I deliberately ignored some of those dependencies? Well, here's where Gearset gives me another helping hand. Before I deploy, Gearset checks my package and highlights potential missing dependencies, giving me another opportunity to include anything that I might have overlooked, and therefore increasing the chances of a successful deployment. So I'm ready.
I'm gonna go ahead to the predeployment summary. Now here, Gearset will present everything that's being changed, everything that I selected, and what our problem analyzer has brought in. If you think back, we touched on the importance of tracking changes and communicating with the rest of the team. And even when you've got tooling to help with deployments, that advice still applies.
Before deploying, Gearset allows me to add deployment notes so that everyone can understand what changes are being introduced and why. And we can also link the deployments to our work items, helping us maintain a traceability between the two tickets we're working on and the changes we're releasing. So I'm gonna go ahead and add some notes for best practice. So I'll add some deployment notes and give this a name.
Would it help if I spelled it right? Awesome. And then finally, I'm gonna go ahead and pick my Kanban board and find the associated ticket. And at this point, I have a few options.
I can go ahead and validate this deployment. I can schedule this deployment for a time, say, for example, when end users might not be using it, or I can go ahead and deploy now. You'll get a final warning just to say, are you happy to deploy? And once I hit continue, the deployment will start for me.
In this window here, you'll see a brief overview of everything that's being changed. And once it's complete, I've got the successful deployment. Okay. So once I'm happy with everything, I've got a few options, and I just wanna talk to you a bit about the post deployment steps.
So great. Our deployment has worked. But what if the changes haven't actually interacted as we expected to? Something's broken in UAT.
I need to quickly change things. Well, in the deployment history, I will have a list of every deployment the team has attempted. And from here, rather than having to rebuild the entire deployment, work out what's changed, I can view the entire report to see what was there and roll back if I want to. Gearset will take a snapshot of your org prior to the deployment so you can start a rollback comparison, select the items that you've deployed, and revert it back to its original state.
Now this can be a partial deployment or the entire package itself, stopping you having to actually guess what's there and roll back and make everything right again. There's also another step if, let's say, you've deployed to UAT and everything's gone seemingly well. The feature's working exactly how you'd expect, end users are happy with that, the testing's done, and now you're ready to send this to production. Well, rather than having to build it again in a similar fashion to rollback, Gearset is holding on and retaining this for you.
So this time around, I can go ahead and deploy to target. All I need to change now is my target org, and I can keep this change, the same change, moving across my environments. So that's a quick look at Compare & Deploy in Gearset. We've gone from identifying the changes we want to deploy through understanding the dependencies, selecting precise changes, validating our package, and deploying it.
And finally, Gearset helps us recover if something goes wrong or promote the same changes into our next environment when testing is complete. Ultimately, the aim is to take away the manual work and the guesswork associated with Salesforce deployments so that your team can spend less time troubleshooting releases and more time delivering the changes that your ends...
End users need. So thank you so much, folks. That is everything that we had in store today. So thank you for joining the session.
You will receive a recording of this webinar by email so you can rewatch it on demand. And if you'd like to try Gearset yourself, please use the link on the screen to start your own free trial. You'll be able to access the whole platform for thirty days. Thanks again, everyone, for joining and for your attention today.
And I hope you all have a great rest of your day.