Codefresh Platform by Octopus Deploy

My main use case for Codefresh  is building pipelines, changing config, and creating a platform for developers.

When I use Codefresh  for building pipelines or creating that developer platform, I use a template that we bootstrapped for everyone else in the bank. We started building our own dedicated pipelines using this template. It would be in our GKE , as a shared pipeline in a shared cluster that we would use to deploy our GKE  resources.

In my opinion, the best features Codefresh offers are extensibility, flexibility, a lot of features, and it is also very fast. The documentation is really good and helps me in my day-to-day work. We were able to quickly move off Bamboo  and CodeBuild  from Google Cloud  while using the same functionality that we require. Codefresh has really good GitOps capabilities.

Codefresh has positively impacted my organization; it has been amazing. Previously, we would have to build scripts and go into Cloud Build in GCP, and we would have to build our own Terraform  images and run that inside Cloud Build. When Codefresh came along, it was much easier to share code with everyone else because we had a single pipeline and similar templates.

Everyone was more on board since switching to Codefresh. In terms of time saved, I would say one day saved per week. We used to have a lot of toil with Cloud Build, but no more with Codefresh.

Codefresh can be improved with more capability inside the GCP ecosystem. The initial setup felt very manual.

I have been using Codefresh for four years.

Codefresh is very stable.

Codefresh's scalability is 10 out of 10; it is very scalable. We have never hit an issue.

I have never had to deal with customer support.

I previously used Bamboo  and Cloud Build. Everyone used different tools, so that is why they wanted to align when we switched to Codefresh.

We did not purchase Codefresh through the Google Cloud Marketplace ; we had an enterprise license.

I did not know about the experience with pricing, setup cost, and licensing as they have one procurement team, and engineers do not have to do this.

I evaluated other options before choosing Codefresh. We did not like Bamboo as it was being deprecated, so we used Cloud Build.

My advice for others looking into using Codefresh is to have a templated repo and have people start off with that. I would rate this product 10 out of 10.

Our primary use case for Codefresh  is building and deploying microservices to Kubernetes . We use Codefresh  as a GitOps control plane, which is integrated with Argo CD to automate our deployments and manage environments efficiently.

When a new commit is merged into our application repository, our Codefresh CI pipeline automatically builds the Docker  image and pushes it to our registry. From there, we then use the GitOps update step in Codefresh to automatically update the image tag in our separate deployment repository that contains our Helm charts. Since that deployment repo is connected as a Git  source to the Codefresh GitOps runtime, Argo CD immediately detects the out of sync state and pulls the new configuration into our Kubernetes  cluster. This gives us a seamless automated flow from code to running pods.

That is our main use case.

The best feature of Codefresh is the GitOps control plane, which provides a single unified view of all Argo CD runtimes and clusters on the dashboard. It completely removes the black box feeling of a Kubernetes cluster that you see in the CLI. It shows real-time health and sync status of every application across the entire organization.

The unified dashboard in Codefresh has shifted our team from reactive to proactive collaboration. Instead of developers constantly asking the DevOps team for deployment status or manually checking multiple Argo CD runtimes, everyone can see the real-time health of their services in one place. On top of that, we have a job written which keeps the health check on the MS Teams  chat, so the team is aware of the application status.

One final feature that actually makes my life easier is the shared volume architecture across the pipeline steps. Unlike other CI/CD tools where you have to manually cache and upload or download artifacts between stages, Codefresh automatically persists the workspace across the entire workflow. I don't have to worry about the artifacts. This makes passing heavy Docker  layers and build artifacts between the steps incredibly fast and simple.

Since switching to Codefresh, our organization has definitely seen approximately a 30 percent reduction in deployment times. Previously, there was manual intervention required. After adapting to Argo CD, we see fewer manual errors, and by standardizing our pipelines through the step marketplace, we have eliminated the snowflake configuration that used to cause production outages. The GitOps automation with Argo CD has saved our DevOps team roughly three to four hours per week.

The time we have reclaimed from manual deployments has allowed us to shift our focus from maintenance to innovations. Instead of spending several hours a week managing sync errors and building custom scripts, we have implemented advanced security such as SAST  and DAST scanning directly into our pipeline, ensuring every image is vetted before it hits the cluster. Secondly, we have optimized infrastructure cost by dedicating time to fine-tune our Kubernetes resource requests and limits. Third, we have improved developer self-service by building a library of standard templates in the step marketplace. Now, a developer can spin up a complete production-ready CI/CD pipeline for a new microservice in a minute.

While using Codefresh, I still don't see many downsides, but I would say the UI performance with large logs is an area for improvement. When a complex pipeline generates a high volume of logs, the user interface can occasionally become sluggish, jittery, or take extra seconds to render. The only downside I would say is the UI experience and its smoothness.

Although the visibility into Kubernetes is excellent, I would love to see out-of-the-box cost optimization metrics. Argo CD knows how a pod is performing, its status, and its state. There should be some kind of cost optimization metrics shown on the GitOps application where we could save money or perhaps reduce the resources of a particular pod application.

One improvement I would say is a promotion process between environments, from lower to upper environment. Currently, the model with complex promotion logic such as specific concurrency strategies or smart rollbacks when multiple commits hit at once can feel quite manual. I would like to see more automated promotion gates that can handle multi-cluster dependencies without needing as much custom YAML configuration.

My experience in my current field is approximately five to six years.

I have found Codefresh very stable overall, except for the UI jitter issue I mentioned. We have had very few minor incidents such as occasionally slowness in the GitOps dashboard or some image pull features during peak times when multiple deployments are happening. However, Codefresh is generally very quick, and the experience is very pleasant and good.

The scalability has been the biggest win for us. Unlike our old Jenkins  setup where adding more builds often meant the master node would struggle and we would run out of executors, Codefresh is Kubernetes-native, so it scales horizontally by design. As our workload grew, we didn't have to manage the scale ourselves. The hybrid runtime simply spins up new pods in our cluster to handle the concurrent builds and then spins them down when the jobs are finished.

Our experience with Codefresh customer support has been very positive. We are on an enterprise plan which gives us a four-hour target response time, but it usually happens before that time for normal issues and even faster when we have P1 priorities. We have reached out a few times, mostly for clarification on advanced GitOps runtimes configurations or minor UI bugs. The engineers we speak with are very highly technical. They don't just give us a generic script. They actually understand Kubernetes and container architecture, which makes a huge difference. Since the acquisition of Octopus Deploy , we have noticed the support resources have become very robust.

Previously, before Codefresh, we were primarily using Jenkins  before making the switch to Codefresh. The main reason for the move was that Jenkins felt like it was becoming a maintenance nightmare for our Kubernetes-native environment. We were spending too much time managing plugins, scaling the Jenkins master, and writing custom fragile groovy scripts for our deployments. We switched to Codefresh because it offered native GitOps support. Instead of building a custom bridge between our CI and Kubernetes cluster, Codefresh provided us a unified dashboard that natively integrated with Argo CD.

We did not do a full-scale evaluation of other major platforms such as GitLab  or Harness  because we were already using Jenkins and had already started implementing Argo CD for our GitOps workflow. We were primarily looking for a better control plane that could unify these existing tools.

We have seen a definitive return on investment both in terms of engineering efficiency and infrastructure stability. From a technical standpoint, our deployment frequency has tripled because we have moved from manual syncs to a fully automated GitOps flow. We have saved approximately four to six hours per week. In terms of dollars, considering both engineering cost and infrastructure cost, I would say the savings are more than at least $10,000 to $15,000.

The pricing is generally based on a combination of user seats and build concurrency. Since we are an enterprise-level team, we moved past the basic tier onto a custom contract. Usually, our manager manages the billing and all that, so I am a little unaware of the full details of the experience.

If you're considering Codefresh, my biggest piece of advice is to embrace GitOps fully from the start. Don't just use it as a traditional CI tool. Take advantage of the native Argo CD integration and the GitOps control plane. It is where the real value lies for Kubernetes-native teams. I would recommend starting with the step marketplace instead of writing custom scripts.

We have covered the most important aspects. It has been a solid transition from the previous solution. GitOps visibility alone has made it a worthwhile investment for our team. I'm satisfied with how it's currently helping us manage our Kubernetes cluster. I would rate this product a 9 out of 10.