Not many years ago, few Salesforce teams had heard of DevOps. Now the average team has at least begun to implement a version control system, adopt continuous integration and continuous delivery (CI/CD), and transform their release process. So what next? Many teams are hungry for more performance gains from DevOps. They want to increase their adoption, but are not always sure where to look. That’s where the DevOps lifecycle comes in.
In this post we’ll look at the different stages of the DevOps lifecycle, the benefits of adopting a more complete DevOps lifecycle, and how to identify your next step to a more complete lifecycle for your team. You’ll also see how Salesforce teams are adopting a more complete lifecycle and find out how your team compares to the ecosystem in the latest State of Salesforce DevOps Report.
What is the DevOps lifecycle?
The DevOps lifecycle is a well-established visualization of DevOps used across the wider world of software delivery. Typically, the lifecycle is represented as an infinity loop, highlighting two things:
- DevOps is an iterative, continuous process. Projects are normally delivered across many short cycles, with a tight feedback loop.
- DevOps combines two traditional workflows of development and operations teams — the left and right sides of the lifecycle.
There’s no definitive version of the lifecycle but Gearset uses one tailored specifically for Salesforce teams to achieve DevOps done right.
The lifecycle captures a complete vision of DevOps. Instead of the stages being an isolated set of activities, the DevOps lifecycle brings them together in a cohesive model. And when every stage is designed to streamline the other stages, the sum is greater than the parts.
Dear Irving on Hudson
Gearset After Hours at NYC Agentforce
An overview of the DevOps lifecycle stages
Plan
The plan stage is where you ideally work closely with end users to gather requirements and design the right solution. What needs to be built and how? Tooling can help here, but it’s a key opportunity for collaboration. The most important thing is to get a deep understanding of the users’ “job to be done”.
The questions during this stage should be guided by the lifecycle approach, such as:
- How could we slice up the requested feature, so it’s easier to test and release?
- What will it look like to deliver a MVP (minimal viable product) so we can start getting feedback on future iterations?
- How will we design for monitoring the performance of this feature?
Build
The build stage is then where you actually make your changes — whether that’s in Agent Builder, Flow Builder, VSCode, or whatever tool you’ve decided makes the most sense for this feature. If the rest of the lifecycle is running well, this is where you should get to spend most of your time.
During the build stage, you can already be bringing in tools for validating your work. You’ll often need to be moving Salesforce metadata around too, even if that’s just committing changes in a developer org to a feature branch.
Validate
The validate stage isn’t the only time you do testing but at this point in the lifecycle you do want to build confidence in the work you’re about to deploy — with an appropriate amount of quality gating in the release pipeline.
- Do the latest changes integrate well with the existing codebase?
- Is the work high-quality in terms of security, efficiency, and maintainability?
- Does the feature function as intended with realistic test data?
- Does it meet user requirements and expectations, based on user acceptance testing?
Alongside some manual testing, automated testing tools for unit tests, UI testing, code analysis, code reviews and security testing are critical to accelerate the process and catch the majority of issues long before they get to a release.
Release
The release stage is about deploying changes to your production environment quickly and successfully. But for many teams Salesforce deployments are time-consuming to prepare and even more tedious to troubleshoot when they fail. Our State of Salesforce DevOps 2025 report shows that most teams actually spend a lot of time on their deployment process.
The release stage is the most impactful stage to address first and where most teams begin their Salesforce DevOps adoption journey — saving countless hours of frustration. With the right tools and process, teams can deploy reliably, then get the whole team (including no-code teammates) using version control, then build an automated pipeline to achieve continuous delivery.
Adopting DevOps helps teams release easily and frequently instead of dreading release day.
Operate
The operate stage is all about protecting end users from downtime or disruption. Salesforce teams don’t have to follow exactly how operations teams work for other types of software, because Salesforce looks after infrastructure and some aspects of security that are typically involved in this stage. But teams are responsible for their data and metadata, and dealing with bugs or data loss.
Backing up data and metadata is essential to secure production, and restore service following disruption. Archiving obsolete data streamlines the performance of your org, as well as reducing storage costs. More and more teams are adopting these tools, as part of a lifecycle approach to Salesforce DevOps rather than viewing them as separate concerns.
Observe
The observe stage is about proactively monitoring org performance and gathering actionable insights. Observability goes beyond traditional monitoring by offering deep and actionable insights. Although it’s a new area for lots of teams, adoption is on the rise as awareness grows about how powerful observability is.
Of teams that don’t have monitoring tools, 74% report that they find out about most issues through end user reporting. They’re often sent a screenshot of a problem, and it takes back and forth just to establish what the issue is, let alone plan a fix. Observability automates that process and helps you catch the signal in the noise. For example, you can monitor for Flow errors, triage them, and resolve issues before users report them.
Observability is also great for:
- Identifying and tackling technical debt with static code analysis tools, so teams have stable foundations for future development
- Tracking all changes across the org — no matter how they got there
- Getting early warnings about closing in on data storage limits
- Spotting unusual data changes that suggest data loss or corruption
The insights from observability feed into the planning stage, joining the loop of the DevOps lifecycle.
DevOps essentials throughout the lifecycle
Security, testing, collaboration and automation are all critical DevOps practices and should be applied throughout the lifecycle — not just at one stage. That’s why these four things are featured in the “halo” around Gearset’s DevOps lifecycle diagram.
Security
Security needs to be a consideration at every stage of the DevOps lifecycle. DevOps done well should always include security, which is why the idea of “DevSecOps” is gaining traction. Security isn’t just about production or staging environments. Data can be exposed in testing environments and even development environments as well. And releases can sometimes introduce security vulnerabilities — catching those early is vital for the protection.
Testing
Testing shouldn’t just be a late-stage step before release. Heavy, end-to-end testing hurts release velocity and increases the cost of delivery. Instead, test automation ensures efficiency and accuracy, catching issues as early as possible such as in the functionality, quality, and security of changes. This is the DevOps idea of “shift left” — bringing the pain forward in the release process when it’s least painful to address.
Collaboration
Collaboration is at the heart of DevOps culture. The whole idea of DevOps was about different functions (development and operations) combining their processes and sharing accountability for their performance as a whole. In the Salesforce context, this is about bringing together no-code and pro-code teams, as well as any other teams that touch the DevOps lifecycle.
Automation
Automation makes DevOps possible. The rapid, iterative workflows of agile development just aren’t achievable without automating processes that are reliable and repeatable. AI advances will open up even more opportunities for DevOps teams to automate tasks that were manual and time-consuming, freeing up capacity to focus on more productive work.
The benefits of adopting a DevOps lifecycle mindset
A roadmap for Salesforce DevOps adoption
The DevOps lifecycle is a great way for teams to measure their DevOps process and identify areas for improvement. How does your team perform in each of these areas? Where are the sticking points and what causes friction there? Where have you got the right tools in place, and where are the gaps?
A typical Salesforce team is strong in the plan, build and release stages — such as having a CI/CD pipeline using Jira, GitHub, and Gearset. But there’s even more potential for improved performance:
- The validate stage could be stronger, with testing, code and config analysis pulled earlier, so that issues aren’t always spotted right before a release.
- The operate stage could be more robust, with backup and archiving in place to keep production secure and streamlined.
- And the observe stage could be transformed with tooling to help proactively find issues in production that need fixing.
A shared model for collaboration
The lifecycle shows the big picture process around which all teams should collaborate. You might find that someone is looking after a particular stage — maybe there’s a security or data team looking after backups which forms part of the operate stage. But is that team integrated with the development team? Collaboration is critical for DevOps, and the lifecycle determines which teams ultimately share accountability for Salesforce as a platform.
Reducing the pain and cost of delivery with “shift left”
Adopting the DevOps lifecycle mindset also encourages a “shift left” approach — looking to fix issues at the earliest possible opportunity, to make later stages less painful. This is probably the most significant way the lifecycle improves teams performance: focusing on the performance of the overall process, not just individual stages.
- Catching a problem at the build or validate stage means the cost is pretty low. You might even be the only person to know it happened. You haven’t wasted much time or effort.
- If it’s caught at the release stage, that’s more problematic. Everyone can see your error is holding the release up until it’s untangled and removed, and you’re back to the drawing board with a lot of time wasted.
- If it’s caught at the operate stage — i.e. in production — that’s the worst-case scenario. This is where end users and the wider business are impacted, fixing it becomes a priority that pushes out other work. This is probably where your boss gets pressure from the business about how it happened.
How does the DevOps lifecycle compare with other lifecycle models?
It can cause confusion that the DevOps lifecycle is one of several different lifecycle models — and there are also variations of each of these lifecycles. The different models overlap and can be complementary.
- Software development lifecycle (SDLC). With more of an emphasis on the development itself, the software development lifecycle is typically shown with stages like: plan, design, build, test, deploy, and (sometimes) maintain. The DevOps lifecycle takes a more holistic view, with a concern for ensuring that end users get the right value and that environments are also well managed.
- Application lifecycle management (ALM). ALM diagrams can look very similar to SDLC diagrams. In contrast to the DevOps lifecycle, ALM and SDLC are more agnostic about agile development — they don’t necessarily rule out a waterfall approach to releases. Before DevOps gained traction in the Salesforce ecosystem, ALM was a commonly used model.
- Data lifecycle management (DLM). The stages of the DLM tend to be something like: create, store, use, archive, destroy. The data lifecycle isn’t directly about development, and so in one sense there’s little overlap between the DevOps lifecycle and the data lifecycle. But Salesforce teams adopting the full DevOps lifecycle need to keep an eye on data: it’s used in test environments, and it affects the performance of production.
Find your next step around the lifecycle
Data gathered for The State of Salesforce DevOps 2025 shows that the highest-performing teams in terms don’t simply adopt more of the lifecycle — they manage the lifecycle with a consolidated set of DevOps tools. Ready to see how your team compares to others across the ecosystem? Read the full ungated report for an overview of DevOps adoption and performance across the Salesforce ecosystem, plus teams’ reported ROI for Salesforce DevOps.
Gearset’s platform for Salesforce DevOps has been designed to support the full DevOps lifecycle. Speak to our DevOps experts about your process, and explore how Gearset can set you on a path towards modern DevOps best practices, full lifecycle adoption, and significant performance improvements for Salesforce delivery.
