We’re thrilled to announce the introduction of feature release workflows for Harness Feature Flags, called Pipelines. Users of Feature Flags can now standardize the process and steps required to release a feature, and layer in automation to make feature release as simple as hitting “Go.”

Feature Release Management Is A Chore – Schedules, Approvals, Monitoring – Oh My!

The most common implementation of a feature flags solution is one that is built in-house. In fact, most of the time people don’t even realize they’re building a feature flags solution! And that makes sense. There are a number of point problems that can be solved with feature flags, and engineering teams want to solve those. But before they know it, it’s turned into another internal tool to maintain and upgrade.

What makes this difficult is two-sided:

  1. It’s hard to scale a solution that was built to solve a specific problem and now it needs to do more, especially when it’s not an engineer’s main job.
  2. The solution inevitably will need to integrate into the release process, which includes scheduling, approval, and monitoring.

Process is important, especially as organizations seek to maximize the value of the feature flag solution that they have built or bought. Even for those who have bought a tool, it’s critical that they are able to create a standardized release process that anyone can follow, and that guarantees that any feature release has gone through the appropriate steps. And let’s not forget about being able to audit releases for compliance purposes – or because something went wrong and a root cause needs to be identified.

When we look at all of these things together, it becomes obvious that all of the requirements are interrelated. Let’s be clear about the problems that need to be addressed. And who knows, maybe there’s a way to solve them all at once!

  • Integration into the release process: monitoring, approvals, scheduling, etc.
  • Standardization of feature releases across teams, products, projects, etc.
  • Ability to view audit trails for compliance and root cause analysis.
  • Creating a common framework that anyone can work off of.

You can imagine that being able to do this would be a massive burden taken off the shoulders of anyone wanting to use a feature flag solution, whether they’re a developer or a manager. If you were able to solve these problems, you’d essentially make feature releases non-eventful.

And maybe… you could even automate it?

Enter Pipelines: Feature Release Management Workflows

To solve these problems, we built Pipelines for Harness Feature Flags. Pipelines take all of the requirements and problems to be addressed above and put them into a single construct that is significantly easier to comprehend and use than the traditional hodge-podge of tools, logs, scripts, and emails.

Building Workflows for Common Release Requirements

Check out this simple pipeline below. Even though there are only three steps, it clearly outlines what you want to happen: turn on the feature; get an approval; and then release to the rest of the beta segment of your customers. 

Simple Feature Flags Pipelines

If this were your actual release process, you could easily take this pipeline and turn it into a reusable template. Now, every time you have a new feature, you could just click a button and feel good that all steps will be taken care of. Of course, these can get more complex as well. Let’s take a look at what that could be:

Release Pipelines

Part of what makes Pipelines in Harness Feature Flags really useful is the deep library of integrations into tools you and your team probably use. Now we can expand the simple use case above where only an approval is required. The workflow could include updating Jira tickets, sending Slack updates, verifying logs or health metrics… Basically, anything you might need in order to release a feature.

Now you’ve taken all these disparate activities and rolled them into a single, manageable workflow. If something goes wrong, you can easily access the audit logs to see what changed, who changed it, when, and so on. You also have a visual pipeline, should you choose to use it, that you can use to quickly spotcheck the progress of a feature rollout or verify that the right steps are included.

Automation of Feature Releases

It’s not just about eliminating the toil and headache associated with feature releases by creating templatized workflows. You might have picked up on the nature of Pipelines, which is that it can be automated.

Once a Pipeline is created to meet the needs of your workflow, you can associate any feature and simply hit the proverbial “Go” button. From there, the Harness Pipeline will take care of going through each of the steps that you’ve laid out. It can automatically handle rolling out the feature, pinging people for approvals, making changes in Jira, checking health metrics – you name it. Of course, if there are issues that require attention or failures in the process, you will be alerted. This leaves you to do things other than babysit the release pipeline, and you only need to be involved if something goes wrong.

Feature Flag Pipelines Toil

In the near future, we’re also looking to integrate automated health metric verification that will take this a step further. Imagine you want to roll out a feature to a subset of your users, verify that things work as expected, or that the right business metrics are moving, and then progressively roll that out to larger portions of your user base. Or, if something goes wrong, you want to take some pre-specified remediation action. All of these things will be possible, meaning that you will truly be able to simply declare what you want, and the system will take care of making it happen.

FF Automation

Added Value of the Harness Platform

As an end-to-end software delivery platform, it wouldn’t make much sense not to have Harness Feature Flags have some interplay with the rest of the software delivery process. We commonly see that feature flags are an amplification method for CI/CD and in many ways are the third step of the CI/CD pipeline.

Harness is actually the only feature flag solution on the market today that natively integrates with CI/CD. Why does that matter? And what value does that provide to a product development or ops organization? And why do executives care about it too?

Let’s start with a topic we’ve already covered – automation. The same Pipeline feature in Harness Feature Flags is also available in Harness Continuous Integration and Harness Continuous Delivery. Yes – you get a unified pipeline. Suddenly, you go from disconnected CI/CD and feature flagging to a single pipeline that shares context and can be automated from build through to individual feature delivery to end users. Can you imagine what that could mean for your software delivery process? But that’s not the only reason it matters.

Analytics, governance, compliance, risk – all are other really important reasons to have CI/CD and feature flags linked up. By having shared context across the entire SDLC, you’re able to do all of the above better:

  • Create a canonical analytics dashboard to track software delivery metrics at each stage, and the interplay between them.
  • Enforce org-wide governance policies for software delivery, and ensure that governance standards are always met.
  • Leverage audit trails across every stage of software delivery to see exactly what’s happening and where, and simplify external and internal audits.
  • De-risk release at any stage because you’re not worried about inter-tool integrations or support and critical context being lost that can impact the business or customers.

Of course, you can go into more detail about any of these topics on our blog, which speaks at length about each of these topics.

How to Get Started

If you’re already a Harness Feature Flags user, you can head over to the product and you’ll see a new menu item labeled “Pipelines” that you can click and get started building your own!

FF Pipelines

If you haven’t signed up to use Harness yet but want to get started, you can easily sign up for a free trial. Happy developing!