UrbanCode Deploy Reviews

It provides a wide list of OOTB plugins for middleware.

By standardizing the automated deployment application process, reducing the amount of errors due to manual steps and by providing visibility into the release cycles of various teams/applications, we've improved our global efficiency by at least 25% and still counting, since we've only used the product for a short period of time.

Getting the deployments automated adds a lot of value. Before we automated deployments, there was a big problem with manual intervention and people making changes on production services and forgetting what they did. It was just impossible to reproduce deployments.

Then there's the traceability aspect -- you can trace back to the code which is stored in ClearCase through the build. All the deployment artifacts can be traced back to the original source.

The biggest area of improvement that I would suggest is in the upgrade process. We started 2015 with uDeploy 4.7, and in order to get the latest version, we had to upgrade first to version 5, which was introduced for the IBM branding. That was straightforward enough, but the jump from version 5 to version 6.1.2 was enormous. We had to focus on testing the security model because it was completely new. We documented and tested it in a production environment. Once we did the upgrade, we found another big change in the version implemented, which we didn't anticipate and which caused problems in our production environment. We re-architected the implementation and there were 4-5 failings we had to work through. Future upgrades probably won't be this difficult, but this one was tough.

In terms of functionality, the reporting could be improved a bit. It seems like the new version has better reporting capability, but data visualization would be nice to have.

Our company uses the solution for standard, blue-green, and complex deployments. We have 250 users throughout our company. 

The solution handles complex deployments very efficiently. 

The user interface includes buttons or drag-and-drop options for all functionality. It is easy to create component processes and application or process flows. 

Currently, we are using UrbanCode Deploy, a product from IBM. Before I had a bit of expertise with it at a bank in Belgium that uses recent commissions from computer systems.

Now, I work in Belgium for an importer of Volkswagen, Audi, Porsche, Lamborghini, etc. I'm in the middleware department. What we do is we link all the different applications together.

We deploy UrbanCode as a middleware solution.

In the beginning, this tool was completely new to us, to everybody in the company, actually. At that time, Urban CodeDeploy was not performing well at all. After that, when we started to use the tool more and had some better insights, UrbanCode Deploy started performing better. 

Last week we sat together with some IBM experts to see where we could gain some more deployment type of performance optimization. We still have to do this. We got new recommendations yesterday. We will now see how much effort it will take to implement them. We will not implement them if it takes over 2 weeks. 

If we can gain maybe ten or fifteen percent optimization with UrbanCode Deploy, then we will invest further in the platform. The tool is performing not so bad now.

The most valuable feature is the ability to create a deployment process visually and to see that process executing in real time, step by step, with access to log files and with a click of a button.

It has drastically improved how we function. We can now realize continuous delivery practices. We can automate more and integrate with other system much more easily.

We have 5,000 to 6,000 developers and we wanted to make sure that with such a large community, we were able to scale up to support thousands and thousands of applications, around 4,000 of them. They're all being continuously deployed through UrbanCode.

It's a great product and a great framework. If you're on a team that has a good mixture of both developers and people who operate the environment or have an operations focus, you're going to love this tool because it allows you to easily integrate with your environment.

Our integration involves a portal that allows our developer and app teams to order application environments (similar to an AWS portal). The self-service tool integrates with APIs for deployments that automatically create the integrations required to develop and deploy our code. So UrbanCode's APIs have made it much easier to enable application developers to create apps much more quickly with its self-service mechanism, speeding up the entire process. If we didn't have the API, it would make it much tougher for us to support, scale, and do self-service in our application-development process.

One area is with Java deployment. We were able to reduce this from 20 steps to 4 or 5 steps, which is about a 4x reduction in complexity and specification, making it easier for our Java developers to develop and deploy their code.

The other area is not just with the tool itself, but with company culture and taking advantage of technology. UrbanCode Deploy has really transformed the way we do code deployment, connecting development and operations more closely. We're almost 100% of the way there with a cohesive devops, which I can quantify at about a 28% improvement.

We use this solution for deployment automation. 

The most valuable functionality is the ability to define the deployment process, schedule the deployment and automatically execute the deployments to different environments. 

We also have integrations with our custom tools which are in UrbanCode Deploy. We don't use the UrbanCode Designer, which is part of the product, but this is mainly because of our conservative approach to security. 

We use UrbanCode Deploy for storing the artifacts of the environment. 

In both our production and non-production environments, we rely on UrbanCode as an artifact repository. For example, if we want to deploy something in production then we take our usual steps, such as stopping what needs to be stopped, then we deploy using UrbanCode, and then we restart to make our production environment available again.

This solution is also useful for maintaining different versions of the artifacts because it has the capability of maintaining snapshots.

The most valuable feature is the snapshot functionality, which allows us to access previous versions of the artifacts. I can see what versions are there and it has helped a lot in one of my products that has many different artifacts that need to be managed. UrbanCode shows me which versions of which artifacts are in each environment.