Earlier, we talked about the importance of DevOps as a practice in Salesforce. If you are familiar with legacy release management for Salesforce, you know that all that’s needed are two orgs: one where you make changes, and one where you deploy. DevOps is a different approach that allows you to innovate at scale without sacrificing trust.
In legacy release management, changes are moved using simple tools such as change sets, first-gen packages, or ANT scripts. The movement of code is often manual, or at least involves many manual steps. This approach is workable, but at scale it slows down (and often breaks down), leading to increased costs and an erosion of trust.
Appirio DX powers the modern Salesforce DevOps stack
When your organization adopts a to DevOps approach, you introduce a set of tools, or a “stack,” that regulates and automates the flow of changes. We often speak of three main phases in that flow of code — building, testing, and deploying — as it moves through the stack.
This stack is what allows us to scale. It provides a common path for multiple, independent developers, teams, and workstreams to move their work toward production in a controlled and regulated manner.
This stack is not unique to Salesforce. The same approach drives software development across nearly all languages and platforms. We’ll talk a little more about the benefits of not being unique in just a bit.
At the heart of the stack are two tools: version control and continuous integration/continuous delivery (CICD). In many ways, these are the defining characteristics of a DevOps stack:
- Version control is the gatekeeper for changes to source code. You may have version control in your current process, maybe functioning as a backup. In DevOps, version control regulates operations.
- CICD drives automation. It is triggered by the version control system to run quality control scans, security analysis, deployments, and other steps.
When you have these two systems at the center of your process, you have DevOps. Anything else, and you are not quite there yet.
So what’s with the rest of the stack? All the other pieces are used as either inputs from or outputs to version control and CICD.
Production, QA, SIT, and UAT are at the top of the stack. They are your shared environments. Development does not occur here; rather, these are all used for in-situ testing, user acceptance, and other quality control scenarios that are not feasible in lower-level environments.
Scratch orgs and developer sandboxes are at the bottom of the stack. These are isolated development environments where features are created. What is built here is promoted into upper-level shared environments by version control and CICD.
Developer tools are the bridge between your team and their development environments. At the most basic level, they turn orgs into source code, and push that code in version control to be saved, shared, and tested.
Testing tools are adjacent to the entire middle of your stack. These include unit tests, automated test suites, static code analysis, static security reviews, and others. As your DevOps process matures, there will be a growing focus on this aspect of the stack to increase the velocity and overall quality of your innovation.
Although some parts of this stack must be unique to Salesforce, large portions can be platform-agnostic, which means two big things:
- You can share this stack (and its maintenance) across your various platform development teams.
- You can take advantage of the rapid pace of tool innovation across all of the software development ecosystem and not just the things that are for Salesforce.
These are key aspects of the design philosophy behind Appirio DX — let’s treat Salesforce like any other piece of software. We don’t need a “Git for Salesforce” or a “Jenkins for Salesforce”; we just need to use Git or Jenkins.
Appirio DX doesn’t replace any piece of your DevOps stack. It isn’t a version control tool or a CICD tool. It is the connective tissue that enables you to treat Salesforce like any other piece of software and achieve rapid rates of innovation.
In the coming weeks we will take a deeper look at some of the cultural benefits and justifications for DevOps.
To learn more, reach out to an Appirio DevOps expert.
About the AuthorFollow on Linkedin More Content by Roarke Lynch