Codefresh Reviews

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.

I use Codefresh for Kubernetes applications and to deploy Kubernetes applications. We have used Codefresh for deploying containerized applications to Kubernetes environments, and our organization has adopted GitOps for managing multiple environments such as development, staging, and production, which makes Codefresh ideal for this purpose.

Managing the Kubernetes platform and deploying applications on Kubernetes is very difficult, but Codefresh has made it easy to deploy applications in different environments like production, staging, and development.

Codefresh offers pipeline automation, Kubernetes native architecture, and GitOps workflow integration, which is very useful; without GitOps, we cannot coordinate with the code. It also provides strong integration with container insights, and to see the deployment process, it shows a dashboard that gives clear insights about what is happening. It also provides smart deployment strategies like blue-green and canary deployments, which are very useful for the production release of applications.

Previously, when a developer pushed code, we had to take the code and change the configuration manually, but now through Codefresh's automation, it is easy to deploy through three stages; once it is successful in development, it goes to the staging environment, and after the pull request is approved in staging, it goes to production deployment. For the configuration file, we only have to write it one time, and everything from container to test is done by Codefresh, which has reduced the work for Kubernetes deployment.

Codefresh eliminates the manual process and provides a centralized platform for continuous integration, continuous delivery, and GitOps-based release management. It is also easy to integrate with Argo CD, so it is used on top of Argo CD, making it useful for deployments like Kubernetes.

Codefresh has a learning curve for teams, as the initial pipeline configuration may require some familiarity with YAML and container-based CI/CD processes; a junior engineer cannot configure these YAML files and processes, so it needs an experienced or knowledgeable person with a background in Kubernetes.

The documentation is good, but the person using Codefresh needs to go through a learning curve; they should have knowledge of the things Codefresh offers, so it should be easy to use even for a non-Kubernetes person, and the writing of configuration files should also be easier for them.

I gave it a nine because it has automated Kubernetes deployments, which are not easy to achieve through CI/CD, and it is centralized, integrating GitOps, Argo CD, and Docker-based containerized application deployment, making it a useful tool. The reason it is not a ten is because our developers who do not have Kubernetes and Docker knowledge cannot use Codefresh easily, and the configuration file we have to write is very complex, requiring prior knowledge of Kubernetes and Docker-based deployments.

I have been using Codefresh for the past ten months.

Codefresh is stable.

This is our first established solution, and it is the best platform.

Another choice before choosing Codefresh was CircleCI, but CircleCI was good for Docker-based deployments; however, we wanted something that supports Kubernetes, so we found Codefresh to be better for Kubernetes deployment.

I have seen a return on investment from using Codefresh.

Before Codefresh, we had to plan the strategy, write the configuration file, and run everything; it used to take two to three days to plan and implement, but now it is a one-time job, so it can be done in ten to fifteen minutes, which has reduced a lot of time and sped up the automation and CI/CD, requiring fewer employees.

Previously, the process had to be done by three to four DevOps engineers, which included writing the YAML file, managing the containers running in Kubernetes, managing the configuration file, and checking for successful deployments in development and staging before doing blue-green and canary deployments, but now everything has been automated.

Codefresh has made the most positive impact by reducing errors; sometimes humans make errors, especially during high-pressure times or with a high workload. It can be hard to configure the files, and we can misconfigure them, leading to wrong deployments, but with the one-time job of configuring the Kubernetes configuration file, it is very easy for repetitive tasks, and it has also reduced repetitive tasks by being triggered automatically once the code is pushed.

Initially, we tried the free trial application, and now we are using a team plan which is managed by the upper teams. I would rate this product a nine out of ten.

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.

My main use case for Codefresh is for build and release. For build and release with Codefresh, we maintain the version-controlled file of the pipeline. Once a commit happens, the build will trigger for that commit on that branch through a pull request. It will build the artifact, scan a few images in Docker, then put the artifact registry image in a remote registry, and then publish the deployed artifact to the deployed environment.

Codefresh is a very nice solution to have for build and release. It is similar to a Kubernetes and Docker instruction setup. There were many clusters we had from our different colleagues from different products that we used to maintain. I used to do user administration as well as team administration in there.

The best features Codefresh offers, in my experience, include user authentication, easy maintenance of YAMLs, and overall ease of use. It provides its own Kubernetes clusters out of the box in the given cloud. Codefresh has its own cloud platform and software as a solution.

The integration points with Slack and Teams help my workflow because they provide continuous notifications about whether the build has succeeded or not, allowing us to trial if it has failed for some reason. This keeps us moving forward. If a build passes, we get a notification in the channel, and then our team can start working on the next items from the backlog, and the ongoing sprint continues smoothly.

Codefresh has positively impacted my organization because many projects and products have come together under its umbrella. For example, one product has around thirty to forty APIs, and we have seven to eight products now in that company. They are doing really great with Codefresh.

Codefresh has helped save time, reduce errors, and improve collaboration across teams. The integration points help us to reduce time, improve performance, and make collaboration between teams easier to follow. We can have our coffee breaks, tea breaks, and lunch breaks and relax because Codefresh is looking after the things going on.

The challenge that we faced with Codefresh is that it is a complex setup. Kubernetes and Docker are somewhat complex. However, the cluster needs many computer resources to have Kubernetes and Docker running in the pipelines. Additionally, some design decisions made us move away from Codefresh to another vendor for pipelines. When we had Codefresh, it was a very nice solution to have, but partly, we have moved to another vendor for pipelines.

The improvements needed for Codefresh include making it easier to create the clusters. Also, navigating to Docker-within-Docker and Docker-within-Kubernetes needs to be easy and well-documented. It is a very nice tool, but management has decided to save on some costs and follow the process.

I have been using Codefresh for about a year.

In my experience, Codefresh is stable with not many challenges in hiccups or in clusters, but it is somewhat complex.

Codefresh has handled growth and increased workloads quite well.

The customer support for Codefresh has been nice. One of the team members had a few configurations that we suggested to Codefresh, and they took it and applied those configurations within Codefresh's product.

Before Codefresh, we used to use STAR Team. The reason for the change was to simplify the workflow since we needed to maintain two integration points in STAR Team, whereas Codefresh simplifies the workflow.

From my position, I have not seen a return on investment with Codefresh.

I was not involved much in the pricing, but Codefresh is nice because we used to share the licensing, cluster creation, and those accounts around products. If one product needs a certain amount of compute and memory, that compute and memory is provided to that product team from other team members. It is nice to have that. We used to predefine that we needed sixteen GB of RAM, thirty-two GB of RAM, eighty GB of space, and compute, and share that with our team for smoke testing, load testing, and stress testing for the QA teams.

The advice I would give to others looking into using Codefresh is that they need to have that budget. Whoever wants to use Codefresh needs to have the budget and a return on investment. They need to have money from the client or vendors so that they can invest in Codefresh. Otherwise, it is a nice solution if the money is there. Somebody can log into Codefresh and do the project things. I would rate my overall experience with Codefresh a seven out of ten.

My main use case for Codefresh is establishing environments for critical operations and creating a self-service process in Argo CD, providing infrastructure and resources and other types of resources using Crossplane, and syncing on a repository through GitOps on Argo CD.

Codefresh helps with the self-service process and critical operations because it has solutions such as Argo CD which give me reliability and establish my environment to provide replicable resources and environments, from stage to production. It gives flexibility and security. We can replicate any time the same type of resources and our infrastructures are auditable.

GitOps specifically makes things more flexible and secure for my team because I am using techniques such as secret storage in VSO, variable secret operator. The secrets operator gives more flexibility, such as rotating secrets and changing all values of security on auditable resources in my environment. I can reach more maturity in our environment using techniques for DevSecOps.

Codefresh impacts my organization positively by improving security and making the time of releases much shorter and faster than the previous scenario with CI/CD implementations.

I notice measurable outcomes such as improved security and the time of releases being much shorter and faster than the previous scenario with CI/CD implementations.

At this moment, I cannot think of anything about needed improvements for Codefresh. Perhaps a native monitoring tool would be beneficial. I use other services such as Grafana, Prometheus, and DataDog, but I do not have native knowledge about monitoring capabilities within Codefresh. However, it would be a good approach to have this integrated.

I have worked with DevOps and correlated areas for up to ten years.

Codefresh's AI capabilities are stable. My environment is very secure and stable, and the accuracy needed during a process of AI capabilities does not disappoint me.

Codefresh handles scalability as my workloads grow by allowing us to implement techniques such as HPA. During the GitOps process, I implement this type of metric because we can apply auto-scale or improve our environment when necessary. It is used to create many more clusters and nodes.

The best features Codefresh offers are CI/CD pipelines, and I do not need to use them because in my scenario, GitOps replaced the whole process of CI/CD. This gives me more flexibility and security, eliminating the need for manual implementation and testing of all steps in production. We can reproduce all solutions in different branches using GitOps practices.

I have already obtained a certification in GitOps from Argo CD and Codefresh because it helped me gain clarity and direction for what to do and the best approach using GitOps.

Codefresh's AI capabilities give me much more visibility in large environments because we can replace some manual tasks with AI capabilities.

Codefresh integrates with my existing DevOps toolchain through integration by Argo CD on the GitOps process. It has much more flexibility and gives me much replaceability for all I need in my environment.

Codefresh handles compliance requirements in my organization because we do not have manual intervention for developers and other people. We only need to run by using least access security, least privilege, and zero-trust policies. We can organize and provide much more security in the environment.

Codefresh supports collaboration across different teams or departments by allowing us to use pull requests by environment on the Git tool. This way, we can funnel things and not have a bottleneck in the environment. We need a parallel and serial utilization of the environments, and we can promote each feature the right way.

Codefresh helps me with disaster recovery or rollback scenarios by tag or number of resources. In this case, the number of the branch or version of the commit of the branch. We can promote the least impacted resources, and the self-healing in the environment gives much more maturity to the software.

Codefresh helps with cost optimization in my organization by identifying resources that are not created manually, and we can make them auditable by GitOps.

Codefresh supports observability and monitoring in my environment by letting us know the exact moment when each team or group is running any deployment or any change on the infrastructure. We have total control over each resource and environment, and this helps us with monitoring and observability, so we do not have surprises during the day.

My advice for others looking into using Codefresh is to study your environment. Before implementing GitOps, you need to check exactly what you need and what you do in your environment to get the best advantage you can during the usage of GitOps. I rate Codefresh nine out of ten based on my overall experience.