The Latest and Greatest in DevSecOps

At Calavista, we were interested in DevSecOps before there was an overall term for these best practices in software development. We were founded on concepts such as Continuous Integration and Continuous Delivery, pioneering Agile development. Since the early 2000s, the software development and DevSecOps scene has changed dramatically, exploding with new technology to help streamline production pipelines. It can be hard to keep up. Considering this, we’ve compiled a list of some of the most exciting and relevant recent developments in the DevSecOps scene.


Increased Adoption of GitOps

There are many different programs for development, but the rise in popularity of Git-based platforms for distribution and collaborative development has led to a new breed of DevSecOps: GitOps.


What is GitOps?

Git is a code management system used by many developers that allows multiple branches of code to be created and then merged seamlessly. It is used to manage multiple versions of source code edits, tracking changes, and merging branches for an effective workflow. Incorporating these workflows into DevOps pipelines gives us GitOps.


How to Take Advantage of GitOps

GitOps falls under DevSecOps because of its relationship to Continuous Delivery. To take full advantage of GitOps, one needs to already have a plan for continuous delivery mechanisms in place. This way, when code is committed in the Git repository, it can be containerized (or built) and incorporated into the CI/CD process.

Argo is an example of a GitOps tool that can interact with Git and the CI/CD pipeline, comparing and synchronizing Kubernetes cluster states across locations and taking charge of continuous delivery. GitOps tools can further streamline development processes by making it easier to address issues within clusters without disrupting the environment.

GitHub Actions enables GitOps not only for Kubernetes, but for deployments as well. When new features are developed and pushed to GitHub, the Actions scripts are triggered to start the CI/CD progress. Since this happens automatically, there’s less work required to launch a new deployment and no risk of forgetting an important step. This approach also scales with multiple environments like QA and even PR (pull request) environments.

Blending Git with DevSecOps practices makes it easier than ever for software development companies to effectively manage, monitor, and integrate code throughout the development process. This makes GitOps a powerful addition to the DevSecOps world and one worth keeping an eye on.


Serverless Computing

DevSecOps is all about keeping developers focused on developing and streamlining their workflows, so it’s no wonder serverless computing has taken off in the world of DevSecOps lately.


What is Serverless Computing?

Taking advantage of cloud computing models, cloud providers can offer software development companies the opportunity to effectively go serverless.

Serverless computing is a cloud computing model that can dynamically scale the allocation of servers automatically and on demand, so users don’t have to worry about server provisioning, availability, or maintenance.

In this way, serverless computing is not truly “serverless,” but from the developer’s perspective it might as well be. Serverless computing platforms like AWS Lambda or Azure Functions allow you to create and deploy code that doesn’t care what server it’s on. Hence, you create code that can be run 100 times, 1,000 times – or even more – in parallel, and you don’t have to worry about what hardware is needed.  It’s all taken care of behind the scenes in the cloud.


The Benefits of Serverless Computing

As mentioned above, serverless computing allows developers to focus on writing code and deploying it to the cloud, with little thought about the underlying infrastructure. Not only does this free up developer brainpower, but it also makes it easier to integrate code in different environments, scaling well with DevOps environments.

Since serverless code can be run in parallel, it is highly scalable and cost-effective. Rather than paying for and running servers for the maximum-expected capacity, users only pay for the resources used while the code is running- resources that are dynamically adjusted to needs. Users are given just what they need, and if demand suddenly increases, the cloud provider can automatically adjust and keep things running smoothly. This not only saves money but takes infrastructure management out of the question for development teams.

The scalability, affordability, and efficiency of serverless computing warrants a shout-out for exciting new DevSecOps developments.


The Rise of DevSecOps

Finally we get to DevSecOps, a newer term that we’re embracing instead of just DevOps. Phishing and Cybersecurity attacks have been on the rise, so it makes sense that DevOps pioneers are starting to incorporate security into DevOps pipelines, creating the field of DevSecOps.


What is DevSecOps?

By integrating security into development and operations practices, organizations can build and deliver secure products efficiently and safely.

DevSecOps refers to incorporating security concerns into DevOps pipelines by automating security  processes and building processes to quickly detect and respond to security threats.

Modern threats (such as supply chain vulnerabilities and ever-evolving threat actors) require modern solutions: integrating security into every step of the development process. DevOps already heavily relies on automation to streamline development, so it stands to reason that automation can be used to secure development processes as well. Automated testing like static application security testing (SAST) and software composition analysis (SCA) are two types of DevSecOps tools that can take your security to another level.


The Importance of DevSecOps

DevSecOps brings the convenience of DevOps to security while integrating security into the development process.

DevOps principles like automation allow software development companies to ensure applications are secure without sacrificing development time or hiring a large application security team. Static code analysis should be performed automatically with every code commit, allowing developers to have prompt security feedback on the code they write. The longer it takes for the vulnerability to be uncovered, the longer it will take to fix the issue.

With automatic feedback, developers have their recent task at front of mind and no additional features would have been built on top of that vulnerable code. This means more secure code will be baked into the product over time.


Securing Your DevOps Environment

DevOps, with its many integration points, can be vulnerable to attacks from different fronts. It is important to approach DevOps practices in a secure manner to make sure the process is continuously secure.  With so many security tools and scanners on the market, even when development frameworks are secure by design, attackers can exploit a system by coming in the side door of the DevOps pipeline.

One way to secure DevOps is to implement secrets management, and another is configuring least-privilege permissions on cloud accounts and storing those credentials securely. These practices don’t help developers write more secure code, but ignoring them can leave even the most secure code completely vulnerable to various attacks. Therefore, they are a necessary component of a DevSecOps environment.



The increased adoption of GitOps, serverless computing, and the shift towards DevSecOps are some notable elements in the world of DevSecOps that we are excited about. However, these are just a few exciting improvements in the world of DevSecOps. Considering DevSecOps is almost synonymous with innovation, the field is always expanding. Keep up with latest best practices and development techniques by following our blogs, and if you have any questions about how to integrate some of these techniques or adopt other DevOps principles email us at

Share on Facebook
Share on Twitter
Share on LinkedIn