NEW FEATURES
MISSING SUBTEXT

Dependency Resolution is live! Enjoy efficient Salesforce deployments.

Our latest feature offers proactive suggestions so you can avoid dependency errors and better understand relationships between your Salesforce objects.

June 3, 2022

Picture the scene: you’ve finally implemented this great new feature in your developer sandbox, and you’re ready to push it to pre-prod to share it with your team. Everything works well in your personal org and you’re super confident about your changes. Yet, as you prepare to deploy your change set into pre-production, things fall apart. The deployment validation fails, some dependencies are missing, and you are left alone having to figure it out and fix it.

If you’re developing on Salesforce this probably sounds familiar. It’s interesting how the joy of shipping valuable changes to production can quickly be undermined by the shortfalls of error-prone deployment processes and tooling. The specific problem at hand here is tracking dependencies in your Salesforce code, and we‘ve just launched a new feature to help you and your team with precisely that.

Dependency resolution: your new helper when preparing deployments

One of our core values at Blue Canvas is to be delightful. That can translate to things like having a nice UI or straightforward onboarding process, but at the core it’s genuinely about accompanying the developer along their journey of shipping changes in Salesforce. This is exactly how we’ve approached Dependency Resolution. It is a layer on top of the existing deployment workflow in Blue Canvas, proactively informing you about the fields, classes, layouts and other objects you’re currently missing.

Here is a quick view of what you’ll now systematically get in Blue Canvas:

The Required Tab indicates which dependencies are missing

Whenever you include new files in your deployment request, Blue Canvas will resolve their dependencies, and proactively suggest files required for a successful validation in Salesforce. This all happens in the new Required Tab in the bottom pane, where you can just check-in dependencies and be good to go. Not to mention:

  • This is continuously verifying dependencies as you add and remove files
  • It works for all types of metadata (classes, layouts, pages, fields etc.)
  • It also lets you discover “Related” objects (objects that depend on what you’re currently deploying), giving you a chance to proactively double-check possible consequences of your change

As you open up your deployment request for review (and as pre-validation checks will run), you’ll have the peace of mind that dependencies have been accounted for, and that your deployment is complete. That’s right, no risk of a REQUIRED_FIELD_MISSING error in Salesforce! But instead, a proactive (and lightweight) verification of dependencies in Blue Canvas.

Fixing errors and increasing development velocity 🚀

This feature is another example of us co-building our roadmap with customers and partners. Many times have we seen teams struggle with last minute surprises during package validation. This turns “shipping to Salesforce” into a tedious rinse-and-repeat process where errors are discovered one after the other and teams are slowed down. We’ve therefore built this feature in a similar spirit as Unit Testing, with an end-goal of letting the user know about looming errors as early as possible.

Put in perspective, this contributes to increasing the velocity of deployments. That’s because it’s easier for a developer to include a dependency that’s suggested to them than it is to debug a late error and having to figure out where the missing culprit hides (not to mention context-switching overhead). In fact, we have shared this feature as an early-access beta to a few of our customers and the response is unanimous: it’s a win for productivity and a win for developer satisfaction too.

Ship it!

Feel more in control of your changes

Little demo samples often don’t do justice to the scale at which things have become difficult in legacy applications. A Salesforce app or custom layout which is developed for years has likely turned into a complex codebase, with many intertwined dependencies that simply cannot be comprehended by team members themselves. In fact we believe that this is the very purpose of good developer tooling: take such weight off developers’ shoulders, so they can keep their focus on business logic and coding great features.

Our intent with dependency resolution is to help you regain control over your codebase. Instead of being overwhelmed by the chain of dependencies, you benefit from a smart companion which untangles this for you. What’s more, you can use it to better understand your codebase, with a clear view of relationships between classes, layouts, and fields. We believe this can be a great helper for new team members, or team members that are working on a new part of the application (or on a new project altogether).

Follow the guide!

It’s already live!

Now that we’ve introduced this feature, we can only encourage you to try it out! We’d love to hear your feedback and we invite you to sign up at https://accounts.bluecanvas.io/signup if you haven’t done so already. Just connect your orgs, compare them in seconds, and as soon as you prepare to push changes from one org to the other, you’ll notice our dependency helper chiming in to help out. 🙌

We hope you’ll love the experience and look forward to delight you with more new features this year. You can stay in touch by subscribing to our Newsletter, or following us on Twitter @bluecanvasio !

Best,
The Blue Canvas Team

More like this