Description
Deploying Salesforce Flows with change sets can be incredibly frustrating. With no visibility, you often lose track of versions, overwrite work, and see deployments fail. In this 30-minute webinar, Cristine Moret-Otero from MathWorks outlines how she uses Gearset’s Flow Navigator to deploy Flows successfully, first time. Cristine walks through a real-world deployment scenario and compares the traditional change sets method with Gearset’s new visual solution. She also shares best practice guidance to help you save time and take the pain out of Flows deployments.
Learn more:
Transcript
As you're joining this webinar I'm just assuming a lot of you are familiar with feeling very frustrated when you're deploying Salesforce flows with ChangeZets.
There's no visibility so you lose track of versions, overwrite work, and probably see deployments fail too.
Well it doesn't have to be that way. In this webinar Christine Moret Otero, senior Salesforce developer at Mathworks, is going to show you how she deploys flows successfully first time.
If you've got any questions for Christine as we go through please do drop those in the q and a box and we'll hopefully have some time at the end to go through those with Christine.
Okay. Over to you, Christine.
Thank you, Nicola.
So as Nicola mentioned, I'm Christine Martotaro. I'm a senior Salesforce developer here, with the MathWorks team.
I've been, on the Salesforce platform, working in the Salesforce platform now for about eight years.
And on a personal note, I am a gardener. I currently am a plant mom to about eight plants.
And here is the QR code on the left, if you wanted to connect on LinkedIn, and just shoot me a message. Feel free to shoot me a message.
Alright. Let's get started.
So what we'll be covering today, we've already gone through the quick intro, but we'll be going to through a deployment scenario.
We'll also be going through comparing chain sets and, gear set flow navigator, And then we'll go through a demo session of the Flow Navigator, and then we'll save questions towards the end.
Alright. Let's get started.
So here we have our deployment scenario.
The business wants to streamline, right, the process of creating and cloning cases, cloning case case record types based on the specific, custom field called support tier on account record. So the focus is to provide an efficient experience, right, by limiting the screen to key fields, and also limiting record type options based off of that dependent field right on account, which is support tier. Some of the, deployment, components are gonna be, of course, flow.
We'll have custom field and standard fields, some page layouts, record types, and quick actions.
So let's go ahead and dive in.
So here, in the change sets, we've all, right, experienced this screen in the past or in the current present.
Now what I've highlighted here for change sets, you'll notice is that I've highlighted the flow here in red, the box. I've also highlighted a potential missing component, which is a custom field on accounts.
That gold field API name correlates to the support tier field that we talked about on the previous screen. So some of the key, right, challenges with change sets is that we don't really have visibility into the changes or of the components that we're moving. Right? It's a pretty static interface, like, as you can see here on the screenshot with just the names. I mean, we don't really get much visibility into what exactly is being changed on that component, particularly with flows.
Also, when we're, talking about bigger, right, packages, there's a lot of rework, that needs to happen with change, change sets when we miss dependent components, such as the example here. Right? We're missing a custom field in our potential package that we're putting together with change sets.
And you only really realize that until you get to the next environment in your change set flow, and you it it tells you it can't, you know, deploy due to a missing component.
Also, there's, failed validations, right, that happen later in the process as well. It's very much you put together your change set in your dev environment, and you, just ship it off to the next environment. Right? And then only then when you receive that inbound change set, do you tar start to see, oh, there's a missing component or it failed validation against your next environment. Right? It's very late in the process that notification of validation of validation error.
So, what what can we do to improve this? Right? So let's take a look at gear set flow navigator and how that looks like. So in the gear set flow navigator scenario, we have this beautiful screen, and I wanna call out that this is the gear set flow navigator, comparison feature. Right? This looks a lot like flow builder, but it is not.
So we can see very, very called out very nicely here on the left side navigation, all the components that are changed, within our flow. We also have this beautiful view on the right of exactly like you would get with the flow builder tree within Salesforce with the addition of the changes being highlighted. Right? So that's also very, very useful.
So, some key things that to call out with Gearset flow navigator. As you can see, it the Salesforce slide displayed highlights changes, but also within Gearset, you get problem analyzer, which highlights potential missed components with your deployment packages. And once we get into the demo, I'll I'll call it out and show you guys what that looks like.
Also, there's efficient package validation.
So you're able to validate your package before you even attempt to deploy it onto your next environment, which is very useful because you can quickly check to see if it'll pass the validation and then proceed to either schedule it or deploy it right then and there on demand.
If it fails validation, then no big deal. You can just go back and edit your package, and we'll see what that looks like in a second with the demo.
Right. Let's dive into the demo.
So what we're gonna do here is switch over screens.
So I'm just gonna briefly walk us through what the change, right, is with, you know, viewed within Salesforce.
So here we have the support tier on the account record page that we were talking about. Right now it's set to bronze. So if I were to create a new case here, it would take me directly to creating the case because bronze tier only really has access to one case record type. Right? But what happens if I change it, right, to a higher tier, silver, for sake of example?
So let's go ahead and save that, and let's launch the same flow. So here, I'm not actually offered the option to select a record type because I'm able I have access to different record types for this support tier. So that's the, functionality, right, that we described during that deployment scenario.
Alright. So now what we're gonna do is we're gonna dive into what that looks like with Gearset deployments.
So here I've transitioned over to Gearset, and we're gonna get started with a comparison for a deployment. So we're gonna select our dev environment because that's where the changes are. We're gonna click Salesforce organization, and we're going to click integration environment to move our changes over to the integration environment.
So you'll notice here on the bottom right corner, there is an option to select different comparison filters. For purposes of this demo, I've actually prebuilt a filter, right, to, make the process the comparison a little bit quicker here.
So it's going to go ahead and grab, compare, right, between my source environment, which is dev, and my target environment, which is integration right here. And you'll notice that at the very top, we have the flow. So let's actually open up flow builder and take a look at all the features.
So let me just zoom out here a little bit so we can get a better view. There we go. So this would be flow builder.
On the left hand side here, we have six, yes, six changes that are being highlighted. Right? And we'll take a look I'll click through and see what those are in a second. But we can also take a look at at all the components as you would, right, in Flow Builder. So you get a really holistic view of everything, and it's highlighted. Like, my change components are in yellow. Everything that's the same is in gray.
Alright. So let's go ahead and click on a change and see what that looks like.
So So right here, I can easily see that I'm setting default setting right the, record type ID to bronze, and I'm also default setting the priority field here to low. And that's the new change. Right? Feedback came in potentially from the business users, and they were like, okay. Let's set the priority by default depending on the support tier. So if we were to click on this other change, which is set record type ID silver, we can see that for silver record type, we're defaulting the priority to medium.
And same thing for the gold tier. Right? So we're defaulting the priority for to high.
Some other changes that are in this flow as well are, screen changes such as adding that, that, that header, right, with the account name that we saw and the and the and the tier.
So these are the changes that were implemented for the screens. So we it it is much very much, you get the complete holistic visibility to for the changes that you're that we're implementing in the flow, which is great. We even have this little mini map here for larger flows, like, to help with navigation, which is, very, very helpful.
Alright. So let's go ahead and exit the screen.
Let's exit the full screen. So just a couple things to know. Right? We do have, other differences here highlighted, in this in this, compare and deploy. Right? But we're gonna grab the flow specifically, to deploy to our next environment, which is integration.
Okay.
Last thing before we move to the next screen that I wanted to call out, it is that it's very easy to just focus on key components that you wanna compare and deploy. Just simply deselect everything, and you can check off what you want to focus on. So this is very, very helpful to kinda just get a, easier efficient view of what you wanna focus on to compare and deploy.
Alright. Let's head off to the next section.
So right now, problem analyzer was checking to see, right, if there was any potential, depending components missing or any other potential issues, right, with permissions that would impact this deployment. That's, what would be listed here if it found any issues, such as, for sake of example, with our previous slide, the missing custom field, right, with that change that that we saw.
We've already deployed that field and other components already into integration. We're just moving this specific flow change into integration.
So in problem analyzer didn't flag anything.
Alright. Let's go to pre deployment summary.
So right here, we're just giving a description, right, a friendly name, moving flow changes demo, and also just moving the screen changes.
Another important key thing to call out here is that you can actually link your Jira tickets or other ticket tracking systems right to this deployment that you would do.
And it writes back all the information to the ticket, which is extremely useful, huge time saver.
Alright.
So we're just about ready to deploy our changes from our dev environment each integration.
But one last thing I wanted to call out here is that you can actually schedule the deployment. You have the option to schedule it. And you can go ahead and set a a date, a specific time, even have it, email, right, results to certain individuals.
And you can even, add integrations to, Slack, Microsoft, which is all very, very, useful to let key stakeholders know that the deployment was completed.
Alright. So we're for sake of this demo, of course, we're just gonna click deploy now on demand. So let's go ahead and do that.
Actually, let's cancel that because I wanna validate my deployment first. So let's go ahead and just validate my deployment. And this is, the piece, right, where we were talking about being able to validate your deployments prior prior to actually attempting the deployment. Right?
Just to get that feedback. And as you can see here, it quickly it was just a flow change. It quickly succeeded. So we're gonna go ahead and now finally click that final deploy button.
Alright.
So it'll it'll take a couple seconds, but, let's just see what we get. Right? The information.
So as you can see, it was successful as expected.
And we get, all of the information here for what was the source, where did it go. Also, we get lots of information here for the components. So if it was a very large deployment, you would get a a list, right, of everything that was moved. And you get some information here for how long did it take and also information for the, name. And if you connected a ticket, you would see the ticket tracking system information as well here on the bottom.
Alright.
Next, what we'll do, we'll actually, switch screens and we'll go to deployment history. So we can see, right, we just deployed something. So let's take a look at the deployment history.
Here on deployment history, you'll notice that we have two deployments that happened.
So we had a deployment happen from our yes. So we had a deployment happen to stage.
We moved items into stage, and it actually was prescheduled, so it completed right around one ten ish.
And let's take a look at what exactly got moved into stage.
So here we can see it was successful.
And now let's actually take a look at so we can see here, right, that we moved a bunch of components. This was like the base layer of custom object, the fields, and all the page layouts that we talked about in our deployment scenario. So the base components were moved in this deployment. Now what we're going to do is actually the flow changes that we just moved in into integration.
We're going to deploy them to stage.
And we can quickly do that by navigating back to deployment history.
This is the, deployment that we just did together on this webinar. And we're going to grab we can click clone package, or we can use this nifty drop down, and we can deploy to target. So clone package and deploy to target are two different features.
Deploy to target is just gonna ask you, right, where do you wanna send it to?
It's it's gonna default you right, and you can just select right here, and you can just select integration.
But let's say that you wanted to add other changes. Right? We saw that there were other changes, in fact, between dev and integration.
So let's go back to deployment history.
Let's clone this package.
We can select our source, which is gonna be dev and integration.
And we can select our target, which is gonna be stage.
And let's run a comparison.
What this clone, clone package feature is going to do, and it it's same with the, target deploy to target. It's going to take any preselected components that we deployed in that package, and it's just going to automatically select them to be deployed into the next environment.
And we'll see what that looks like in a second once it's done comparing.
It'll be, preselected changes. It'll even pull in, the friendly name and the also the details that we provided when we deployed the original, right, from dev into integration.
So it'll copy over everything exactly the same as we defined it in the original deployment.
So if we were to click selecting items here at the top left, you'll see we only have one item really. It's the flow. But if we have, like, five different items, everything would be preselected. There's no need to rebuild the package again.
It's all there for you. If you had some changes, right, between integration and stage that you wanted to pull in, doesn't seem like there okay. So there are others. So we can go ahead and edit the package.
Right? Pull in other changes. So let's go ahead and do that.
Alright. So we've added other changes.
And that's the key difference between cloning the package and deploying to target. You Can't really edit the package when you're deploying to target. When you clone the package though, you can add additional changes.
So let's go ahead and move to the next screen.
So problem analyzer hasn't flagged anything. Right? We have all the important fields and permissions, dependent components that we need for this deployment. So we'll move on to the next screen, and we'll go ahead and move our changes.
Let's actually edit the deployment notes. Right? Everything's exactly the same as was before, but we've added some stuff. Right?
So let's go ahead and add And let's go ahead and deploy it.
So now it's taking a couple seconds, of course, to deploy the items into our stage environment.
And see here, I chose to deploy it without validating it beforehand. Right? But, that's no issue here because we can just go back to the results.
And for sake of this demo, I'll just remove that account. But we can see that we get notified, right, of any failures right then and there, which is great feedback to get, right, because we can resolve any issues much more efficiently.
Great. So let's go pre deployment page. Let's validate before we deploy, see if we get any other errors.
Right. So far it's passing validation, and now we can go ahead and deploy it into stage.
Okay. So, that pretty much covers the entire scenario. I'll give it a second here just so we can see the successful page.
Now we have successfully moved our items from integration into stage, and we can see the new record, right, for the deployment history. We even get the history on that failed deployment as well.
Now let's say that, we had issues with the deployment. Right? With this deployment we just did into stage wasn't great.
The flow is giving some errors. We do have a rollback feature right here. That way, you can just go ahead and, have the flow revert to its previous version.
Also, any other components that were included such as that object. Also, if we were to roll back, would go back to the original state it was prior to deployment.
Okay.
Let's go ahead and switch back to the presentation. That concludes the demo portion.
Alright.
We'll switch here to the screen.
Just to recap. Right? We saw the sales the gear set flow navigator, feature and, which is screenshotted here. And it is a Salesforce like display, right, that highlights all of our changes just like Flow Builder. Right?
The the tree navigation that we have here on the right.
We can click into each individual component, and we have that visibility for the changes that were made.
We also saw, problem analyzer, just calculating to see, right, if there were any missed dependent components. And we also saw how very, very efficient, validating your packages is. Right?
Critically important prior to deployment.
Okay. Alright.
Here are here are some reference materials that I've included, for, specifically, flow navigator, but also draft deployments, which was that initial package that we saw, right, being deployed into into stage by the at one ten. Right? Also, we have, some materials around configuring comparisons, which is the compare and deploy that we used to move the flow and also managing org connections.
So another key callout that I just wanted to make between, gearset compare gearset and change sets is that with gearset, you just connect all your orgs. With change set, you have to kind of, like, organize, right, the inbound, outbound environments.
With GearSat, it is much more simpler to manage all of those connections.
Alright.
Now we're diving into q and a.
That was brilliant, Christine. Thank you so much for walking us through that real world example.
Good to see what the change sets and and then how you do it now with Gear Set Flow and Avocator. And you're right. Yeah. Let's, we've got some time here for q and a. So if anyone's got any questions, just pop them in the q and a box, and we'll see how many we can get through.
I think we've got one on on a recording. Yes. And this recording will be shared with you all so you can watch back, anything. You can rewatch it or if there's any bits that you've missed.
Okay. For you, Christine, first question. Any tips on convincing colleagues who've always used change sites to switch?
So there are a couple key, right, factors for convincing, fellow colleagues on your same level, but also more importantly, managers, right, senior senior stakeholders.
More import the best, advice I can give is to highlight the value, not only increase in productivity, right, because it is much more efficient to use gear set rather than chain sets with your deployments, but also the visibility as well that you get into what the changes were, who moved the changes, and that granularity that you get to really review, review the changes prior to deploying them because there's no visibility with Chainzatz.
It is quite challenging, right, to to move those changes if you don't know exactly what's going on. Because, the developer that made those changes will know exactly what they're moving. But let's say that a fellow team member that's not necessarily familiar is moving it, then they wouldn't necessarily know. Right? So that granular visibility for anyone taking building that package is extremely important.
Brilliant. What happens if I deploy a flow and find it's throwing errors? How do I roll back?
So, as I highlighted in the demo, you can use that rollback feature. It is very, very useful.
It will revert any and all changes deployed as part of that package. So the in our case, the flow and the object, it will revert it back to its default state just prior to deployment.
And it's as simple as a couple of clicks, and you're done.
Great. Okay. This is, can you give light highlight on Salesforce implementation mythology?
I'm sorry. I didn't quite catch the question.
I think we're looking for I wonder if if they could re reask that question, and we can jump to another one. Did you need training for Gearset slash Flow Navigator?
So, Gearset has a lot of useful, right, documentation in their in their self-service, website. Also, there's dev ops launchpad as well. So there's a lot of resources out there that Gearset have provides to help, new, Gearset users really ramp up quickly and get started comparing and deploying.
