Implementing No-Code Where It Matters
By Skyler Layne
The demand for faster software delivery is making no-code a hot topic in DevOps circles. As a developer, the initial reaction to ‘no-code’ can be down-right offensive. I’ve spent much of my career and personal time writing code and learning about software in all of its various forms. When I first heard the term no-code, it left me wondering if we’re not supposed to code solutions anymore.
Yet, the reality is I talk to customers every day that have trouble building and scaling application automation due to toolchain complexity and a lack of access to skilled DevOps engineers.
No-code CI/CD platforms are aimed at helping get software delivered faster, by enabling a wider group of people to build and deploy applications. While code is always going to be the primary approach in designing applications, there is a lot of merit to using a no-code solution to build and move applications across environments. I quickly came to terms with the value of no-code in the context of CI/CD, knowing it can help accelerate growth and promote innovation for companies who struggle with access to DevOps skills.
No-code CI/CD essentially enables teams to go from commit to production in order to ship their software. This helps address quality and controls without having to spend considerable effort on toolchain integration. The visual nature of the UI also helps with faster setup, training, implementation and ongoing maintenance.
The Challenges of Software Delivery
When we talk about DevOps what we’re really talking about is the name we associate with the combination of lessons learned in software development and applying them to IT Operations. The ultimate goal is to produce a high-quality product while reducing the time to delivery, which in turn adds business value by satisfying the end-users who eventually generate revenue for the business.
Now, let’s talk about what is involved in getting this going at an organization. The two main components to this are technology and process. Before we go any further, no amount of technology can make up for bad process, however, it can help.
If we look at the application delivery chain, you’ll need a few things:
- A way to build code and produce artifacts
- A way to validate artifacts in a low-risk area
- A place to store those artifacts
- A way to get those artifacts to production machines
- A way to ensure reproducibility of those low-risk machines as well as production machines
- A way to validate artifacts in production
Tool Chain Complexity
All of these steps involve at least 1 tool, which means a whole bunch of additional products to learn and manage. To ensure you get the most out of your investment, tools need to be codified in a way that supports the path to production. This means connecting your tools so your applications are tested and validated before it goes to production. Once in production, monitoring, alerting, and logging are essential to assess the health of your application. If you apply automation in the purist sense, all the tools, configuration, and underlying infrastructure should be codified in a way that your team can build it back up from nothing, together or individually, to support the path to production.
Now say, some magic fairy comes along and gives you the keys to the kingdom, by that I mean they give you all the code and knowledge to build and integrate the CI/CD toolchain. Now what? What happens when version upgrades are required? Or when the software in the toolchain is no longer supported and forces you to upgrade. What happens if the application has a changing requirement? Say your app is deployed on VMs, now Kubernetes is a requirement. I guess what I’m getting at is that there is a significant amount of management of ongoing automation outside of your application that needs to be accounted for and a highly productive team to make it work.
Using a no-code solution cuts out all that technology-stitching and the vast amount of complexity that it adds and allows you to focus more on process. An extremely important part of DevOps that is overlooked more often than not!
Consistent Application Delivery Processes
During any DevOps implementation, the topic of processes comes up. Generally, the goal is to define a consistent and secure way for teams to release and deploy applications – and mitigate unexpected downtime and failures. A manual or coded approach is difficult to standardize given the diverse technology ecosystem and high reliance on a handful of individuals.
With a no-code environment, it is much easier for operations to inherit and decipher a build pipeline and augment it with necessary environment configurations, infrastructure and approval gates. It also makes it much easier for team members to identify what is currently ‘released’ and when the next scheduled deployment is going to happen.
Summing Up No-code
No-code doesn’t mean no more developers. I truly think it changes the way developers work. It takes a lot of the complexities out and instead of spending time on the technology outside your application, it allows you to focus and do more of what you’re good at and love.