The primary use case for CloudBees is for continuous integration and deployment. It is primarily used for production deployments. We use it to trigger Autobahn, such as CloudBees, well in advance to clear out many issues upfront, trigger change requests, and test in various environments to be ready with the production deployment on the actual date.

CloudBees has helped our organization by integrating with various systems like version one, GitHub, and PDSM. It reduces the need for documentation by automating processes, saving time when creating documents and testing the application. This reduces the amount of time spent on deployments and helps pull out all the test results and create change requests, providing a more streamlined process for deployment.

The most beneficial aspect is that CloudBees integrates with everything, like version one, GitHub, and PDSM. It automates documentation and testing processes, reducing the need to create documents manually. By creating automated processes, it saves time and effort.

It could improve the document upload process. Currently, documents need to be uploaded manually to the PDSM request. An enhancement could be to have a feature where you can upload documents directly to go into the PDSM request.

For about two to three years, approximately two and a half to three years.

CloudBees has improved a lot over time. Initially, there were challenges setting it up, but once we understood its functions and processes, there were no stability issues.

CloudBees is scalable as it integrates with various complex systems and offers the flexibility to scale to many other application integrations beyond those currently used.

I have not personally interacted with customer service or support since the DevOps team handles template creation and maintenance, and they might have contacted support during the initial phase.

Positive

Before CloudBees, we did not use a similar tool. However, we are currently considering a transition to GitHub Actions.

The initial setup involved creating a template that checks pull requests in GitHub. It verifies approvals, mergers, and other criteria necessary for a build. The setup includes extensive integration with other systems, stringent checks, and a series of deployment stages from QA to production.

The DevOps team is responsible for creating templates and handling integration with various systems. They play a crucial role in supporting the implementation and deployment processes.

The measurable benefits of using CloudBees include a significant amount of time saved during deployment because of the automation and integration capabilities it offers.

I am not aware of the pricing, setup cost, or licensing details for CloudBees.

We are currently using GitHub Actions, with an effort to transition from CloudBees to GitHub Actions.

Follow the guidelines and step-by-step processes thoroughly. If you encounter integration issues with your tools, seek support from CloudBees to ensure integration. Once set up, CloudBees is a reliable tool for deployment.

I'd rate the solution nine out of ten.

We use CloudBees for deploying the code in higher environments, such as QA, C2, staging, and production.

CloudBees has made deployment faster compared to on-premise solutions. It also facilitates working with multiple machines, improving efficiency and performance.

I find the automation feature most valuable. CloudBees is highly scalable and supports both small and large teams. The deployment process is also faster when compared to on-premise.

There are connection issues with CloudBees, specifically between Sybase and CloudBees. We often encounter connection problems, and there are issues with the pipelines.

I have been working with CloudBees for one and a half years.

There are a lot of connection issues with CloudBees. We experience disconnections frequently.

CloudBees supports the deployment of large amounts of data efficiently across multiple machines.

I haven't gone through the technical support, so I can't comment on it.

Positive

Before CloudBees, we were using Jenkins on-premises. We switched to CloudBees because we moved our SQL servers to the cloud, which made deployment easier.

The initial setup of CloudBees took approximately fifteen to twenty minutes.

We used UrbanCode deployment to deploy it in different environments, but I was not directly involved in the implementation part.

I am not aware of the return on investment metrics for CloudBees.

I am not sure about the pricing, setup cost, and licensing for CloudBees. The team takes care of it.

I am not aware of any other solutions that were evaluated before choosing CloudBees.

I would recommend CloudBees to others because building jobs is much easier than with other solutions.

We use a pipeline to deploy our application. All our organization checks and requirements are added to the CloudBees pipelines, ensuring code quality and checking vulnerabilities. We use Jenkins and SonarQube as part of the deployment process.

CloudBees has streamlined our deployment process. Previously, deployment involved manual file transfers and checks, which were time-consuming. Now, with CloudBees, many tasks are automated, making our work easier and more efficient.

CloudBees assists by automating tasks, previously done manually, in the pipeline setup. This saves time and improves efficiency. The features set rules that are regularly updated, reducing the need for constant oversight. One-click deployment processes also highlight the flexibility and ease of the platform.

Sometimes, there are performance issues, however, they may be due to our organization's configuration. Currently, I do not have specific improvements in mind as these might be related to our side.

Previously, our organization had an on-premise solution, but we have moved to the cloud version.

Due to security constraints within our organization, the performance can appear slow. It is difficult to discern if the issue is with CloudBees or our organization's configuration.

CloudBees is scalable, but I cannot provide specific details on how this scalability impacts us.

We experience issues with the CloudBees pipelines occasionally, like resource limits or permission errors. The DevOps team generally resolves these, and I would rate CloudBees support eight out of ten.

Positive

Before CloudBees, we used FTP for deployment, which involved no pipelines.

The setup was managed by a separate team. My experience starts with using the product, which was straightforward.

A separate team, the DevOps team, manages the CloudBees setup and any technical support needed.

CloudBees saves time and resources by executing automated deployment processes, which would otherwise have been manual and time-consuming.

I am not aware of the pricing, setup cost, or licensing details.

I have not evaluated other solutions, as my interaction began with CloudBees directly.

I would recommend CloudBees, especially to those using traditional ways of deployment, because it simplifies and automates many processes.

CloudBees is the Jenkins tool for building and deploying. There's open-source Jenkins, which is free and can be used by any organization, but it offers a different architecture for Jenkins. If your organization is larger, you might choose the architecture. This way, you can have different masters for different applications, and different teams can manage their masters separately. However, a single person can still control all the masters, whoever manages it for the organization.

It has dynamic node allocation for the code we're building. When we trigger a build, like for Java code, it pulls a Docker image from a repository. Then, a pod spins up. If you have ten nodes, the solution uses a Kubernetes architecture. There's one master node and ten different nodes connected to the master. Whenever we trigger a build, a pod spins up and gets scheduled on any of the slave nodes in the Kubernetes cluster. That's the best thing I see about the product. 

The management is good. You don't need to manage different nodes individually. You don't have to specify which node to build the code on. In CloudBees, you can avoid that. You mention the node, and it will automatically schedule the pod on whichever node is free.

You can also configure different nodes. Another good point is that you can configure Elastic File System to store the data.

The setup is somewhat complicated. You need a cloud architect and engineer to set it up properly. The initial setup will take time, so you need a good engineer and architect to handle it.

I have been working with the product for three years. 

I have no issues with the tool's stability. 

I find the product scalable. Currently, we're using a Kubernetes architecture and working on-premises. However, other teams are working on the cloud version of CloudBees with AWS infrastructure. There, we can also scale the nodes.

I'm currently working for an organization that has over 200 applications. They've adopted the CloudBees architecture. So, these 200 applications have 200 different masters. All of this is managed by a single team, which is a separate team. The different applications and different members are managed by a single person who oversees the entire organization, similar to how we have it in AWS.

The tool's support is good. 

Neutral

I don't think CloudBees requires much maintenance, but some things must be considered. As I said, they have a Kubernetes architecture, so Kubernetes patching and Jenkins patching will also be required. It publishes upgraded versions on its website. You can purchase the latest license and upgrade the Jenkins version through that purchase.

I rate the overall solution an eight out of ten. 

We started with the continuous integration product and have now adopted continuous deployment for my current projects. We have a cloud-based product for other environments, like our dev environment and one of our CAT environments. These are the two environments we are using right now. Initially, we mainly used CloudBees for continuous integration. Now, we are utilizing both CloudBees for continuous integration and CloudBees CD for deployment.

When a build starts in CloudBees, it progresses from continuous integration to continuous deployment and monitoring. These are the three areas we're focusing on. We have successfully onboarded over 150 applications, which allows us to gather deployment and CI/CD pipeline metrics. We also have a dedicated service template for different application types, such as Java with Maven, .NET using MSBuild, and Node.js. 

We use CloudBees for continuous integration, deployment, and monitoring. We also started leveraging CloudBees CD Analytics for enhanced metrics and insights.

We deploy several applications using ECS and EKS, enabling us to achieve blue-green deployments. This allows for rolling updates and changes, benefiting many of our customers.

Another important aspect is our analytics capabilities. By leveraging these analytics, we can identify areas for improvement and increase our deployment frequency. We can predict trends and forecast business needs.

We are a centralized team that provides all the CI/CD and automation best practices for our internal teams. We chose a cloud-based product because it allows for end-to-end process automation. Using Cloud-based CI and CD, we can achieve effective release orchestration, enabling us to plan new releases efficiently.

One standout feature is build promotion. With this feature, we can promote builds across different environments with a single click, simplifying our workflow significantly. Additionally, we can easily identify where errors occur at any stage, making it straightforward to resolve issues.

Our automation supports not only on-premises deployments but also integrates with cloud solutions like AWS, GCP, and Azure. This flexibility allows us to deploy in both on-prem and cloud environments.

When I started with CloudBees, I found the configuration at the CD level to be quite challenging when creating end-to-end orchestration or release execution flows.

If industry-standard templates were available—based on surveys of what other companies are doing with their deployment models—it would simplify the configuration process. Collecting this information and providing standardized templates would make it much easier for teams to configure and use the platform.

Most of our configurations were done manually. On the CI side, customization options or APIs could improve the experience when dealing with Kubernetes execution or pod template configurations. 

It would be beneficial to integrate AI solutions like ChatGPT into our CI and CD processes. Many distributed networks and CI tools, like GitLab, are adopting such integrations.

I have been using CloudBees for three and a half years.

When we started using cloud technologies, we faced initial challenges. We initially opted for CloudBees and later integrated CloudBees CD. We encountered setup and stability issues at that time, including connectivity problems and occasional downtimes. The system is now running smoothly.

It's scalable because we've deployed it on high-throughput servers, allowing for efficient operation. The applications can be deployed without any interruptions.

We have 200+ users using this solution.

When we interact with the CloudBees team, we utilize the CloudBees University for support. This platform provides access to technical expertise, and if we need customized solutions, we can reach out to CloudBees representatives through the university.

Positive

When I started working with CloudBees, we focused on creating service catalogs. Given that we have over 2,000 components and applications, we follow various deployment strategies, including ECS-based, SAML-based, and Windows IIS-based deployments. Each of these requires specific template configurations.

We also explored blue-green deployments involving customized configurations we've implemented externally. While I’ve noticed some templates already available, expanding the library of deployment strategy templates would be beneficial. Adding templates for Tomcat, WebLogic, WebSphere, and Node.js deployments would enhance support for our diverse solutions.

Once we onboard an application, we hand off the maintenance and deployment responsibilities to the application team. Our role is to provide the initial solution and support them in getting started.

We have a team of twenty. It takes us one or two days to onboard a new application. This efficiency is due to our well-defined templates and process documentation. When a new application team approaches us for their DevOps journey, we can onboard them quickly, often within one or two days, with an end-to-end solution.

We assess their current deployment setup. If it aligns with our existing processes, we begin onboarding immediately. If not, we work with them to create a suitable deployment model. We have a solid understanding of our major deployment procedures, which allows one person to establish a complete end-to-end solution in about a day.

Once the application is onboarded, the application team takes over the entire release flow. We’re available to provide guidance and support if they encounter any issues or need training.

Even with full automation, some level of maintenance is necessary. Currently, we have a dedicated SRE team to handle this. Our DevOps journey with CI/CD involves a combination of various tools, not just the CloudBees CD product.

Some applications are heavily dependent on GitLab. We are currently focusing on migrating a few of these applications and building them directly on GitLab.

I recommend this solution for smaller projects or teams, as it can be quite effective for them. For those seeking a consolidated CI/CD and comprehensive metrics solution, CloudBees CD is an excellent choice.

Overall, I rate the solution an eight out of ten.

We use it as one of the DevOps tools in continuous implementation. We use the tool for continuous deployment. There are two parts to the tool: continuous integration and continuous deployment. We work for continuous deployments of applications. We have multiple pipelines in our environment and multiple applications. There are about 1,000 applications within our environment. Each application has multiple pipelines and branches configured. We pull the source code from Git. There's also something called a repository. We use Groovy scripts to provision pipelines. These pipelines have multiple stages, starting with SCM checkout, build stage and Sonar scan stage. Finally, it gets deployed to a particular server defined in the code. Before we execute the pipeline, we have different environments for development and production. For development, we test by executing directly. We hand it over to the production team for production to test on the specific branches.

It is a standalone tool, so no networking is possible by itself. However, it can be integrated with multiple vendors. CloudBees, in particular, supports integration with multiple vendors and offers enterprise support, including vendor support. Whenever we encounter issues, we can troubleshoot them with their help, as they provide continuous support. They also offer monthly knowledge transfer sessions for the team working with the tool. Jenkins is a standalone tool without cluster or networking capabilities; you can't integrate it similarly. CloudBees, however, supports different networking components, such as pods, Kubernetes, and Docker, which can all be integrated. CloudBees continues to develop and release new features.

Improvements in resolution time may vary since every environment has different needs. CloudBees is still a growing platform, but it has proven to be capable of supporting enterprise-level pipelines and CI/CD requirements.  

They could increase the number of support channels to expedite resolutions or introduce a chat option similar to what Amazon and other vendors offer. A chat option would make resolving issues quickly and efficiently easier.

New features and updates in the market for tools like Jenkins and others are often developed as open-source projects. Since CloudBees is an enterprise-level platform, it ensures thorough testing for critical environments like production. While CloudBees is doing well in this regard, it's not yet adopted in all areas. We have a dedicated team for CloudBees and receive proper support whenever we deploy.

I have been using CloudBees for seven to eight months.

We haven't encountered any performance issues with CloudBees. CloudBees is hosted on a particular server, either a clustered or standalone one. CloudBees' performance might also be affected if the server's performance is impacted. CloudBees has been stable.

In our setup, the Jenkins server's hard disk, which hosts Jenkins, is used to host the NAS. The NAS contains the CloudBees files. We performed a migration where Jenkins files were copied to the NAS for CloudBees. Through CloudBees' GUI, we refresh or reload to retrieve the required files. This affects every pipeline.

Scaling can be done through the parameters we configure in the pipelines. The parameters are not limited to just one; whatever we need, we rely on plugins, and these can be integrated. As these scripts are further developed to meet future needs, scaling CloudBees becomes even more flexible. Teradata integration has been working perfectly for us.

Scalability depends on the number of pipelines we have. As the number of pipelines increases daily, the number of DevOps engineers required to handle the workload must match. This is because multiple teams are involved, often encountering issues that need troubleshooting. Multiple issues still arise even if we are disconnected, and engineers must resolve them. It depends on the environment and the current number of pipelines.

In our environment, we have almost 1,000 applications. Of those, around 45 to 50 applications are actively in use. Each pipeline is managed based on the environment, such as development or production. There are approximately 713 development pipelines, and the production pipelines are about half that number. The number of users is difficult to count, as different application teams use each pipeline. To be efficient, each pipeline requires at least one dedicated engineer, so it's typically a one-to-one ratio between pipelines and engineers.

A DevOps engineer needs some knowledge to implement CloudBees. Once they approach the CloudBees team, they provide knowledge transfer during a scheduled conference call. They share comprehensive information using reference guides, making it easier to implement. However, engineers should have prior knowledge of Jenkins or CloudCI, which is essential for a smooth implementation.

We have implemented CloudBees in Kubernetes nodes, which are basically in the cloud only. In the initial migration stage; we have it in our local NAS. There'll be a future production, and one will be more for the CloudBees.

We are primarily involved in migrating pipelines from Jenkins to CloudBees. Migration is not difficult for us, but creating a new pipeline and ensuring it matches the Jenkins setup while executing can present challenges. One of the main issues we face is when new plugins are unavailable or when application support for plugins such as Java, Node.js, or Git.js versions is lacking. If the necessary versions aren't available, it becomes a problem.

There are costs involved, but the tool is useful and worth it. While we can rely on Jenkins, it lacks vendor support in a production environment. We are solely responsible for troubleshooting issues. This can be time-consuming, and if it's a production issue, it affects production time. With enterprise support, we benefit from immediate troubleshooting when issues arise, making it a valuable feature.

If you use any plugins or whatever plugins you get, you'll have access to the latest versions of pipelines and branches. Everything, including the most recent versions, will be available. Whether it's a Java version or any other plugin, for example, if it's related to Java, they will provide the latest updates for the currently available versions.

It comes with vendor support and continuous assistance. CloudBees provides regular knowledge transfers about new and upcoming features and supports any issues that arise. For example, if new features are unavailable in the tool, we can raise a ticket or concern, and they promptly address it. They also communicate with us by scheduling calls with our tech leads to resolve any issues in real-time. Since different environments and development teams have varying needs, CloudBees ensures these are consistently met.

Similar to other infrastructure areas, it requires maintenance. Having the right options available is essential to maintaining it properly.

The core advantages of this tool are its enterprise-level vendor support and its ability to handle cluster-level and network-level configurations, which facilitate high availability in the environment—capabilities that other tools often do not provide. These are the two main pros: cluster concepts and enterprise-level support.

Overall, I rate the solution an eight out of ten.

We use the product primarily for automation tasks. It handles various processes that don't require human intervention, making it a crucial part of our workflow.

One recent product feature that stands out is the pipeline explorer, which is providing significant value for us right now.

The platform could integrate better with other tools and support external tools directly.

I've been using CloudBees for about five years.

Over time, we have encountered product performance issues at large scales. However, at small to medium scales, there are no issues at all.

Overall, I rate the stability an eight. 

As long as you follow the vendor's recommendations on scaling, the platform performs well. Adapting to more complex organizational challenges outside those recommendations could be better. However, the support team does their best to handle the issues. 

I rate the scalability a nine. 

The VM-based infrastructure setup is easy. However, Kubernetes-based setup is difficult, even for experts who find bugs and report them back to the vendor.

To effectively use the platform, you need to know Jenkins, as the product is essentially a layer on top of Jenkins.

It's a powerful and flexible system, but it's important to implement proper guardrails from the outset because making systemic changes down the road can be difficult for your organization.

I rate it a nine out of ten.