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. 

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. 

It provides a wide list of OOTB plugins for middleware.

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.

The most valuable feature is auto-deployment of application versions through direct connectivity with UrbanCode Deploy.

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.

For me, the most valuable thing is that we have a full overview of our environment, where we have deployed what, when it went okay, when it went wrong, etc. These kinds of things. 

It is very easy to make a software release. It used to take us at least a couple of hours to make a release, now we went to production with a new one last night. This new release took me five minutes.

It makes it easy to select what we want to deploy and to follow it up afterward. The reports that we get when something goes wrong work very well.

The ability to deploy as often as possible allows a number of people to work on it at the same time.

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.

• The gating and approval workflows.
• The udclient.jar API calls are relatively easy to understand.

We like a few things, such as the calendar, the permissions model, and the process editing. The component template and deployment interface are very good.

There are three main valuable features for us:

1. The ability to deploy objects consistently to any of our multiple environments;
2. Prior deployments and logging stored in a web GUI which can be accessed by any member of the team; and
3. Flexibility of the plugin system to use features supplied by IBM or the ability to write our own.

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.

Plugin-based architecture.

• Rich plugins
• Visualized process design
• Visualized approval process

The valuable features are “scriptability” and customizing the deployment processes.

There are several most valuable features for us.

1. Automation of deployment processes for all our projects;
2. It's user-friendly enough for our development team to access and use on a daily basis; and
3. The lead approval process is one of the unique features in it that can't be found in any other automation tool.

• Automatic detection of new builds (via an agent on Nexus).
• The ability to easily create a custom deployment workflow in the web interface.

Reusable templates make your life easier.

Gates is one interesting feature, which will help approvers provide their approvals in advance, without having to rely on when deployment happens.

It has out-of-the-box integration with source-code repositories, various ticketing systems, plus a wide variety of plugins to use during deployment. Custom plugin development was easy and the tools capability of keeping the version tracking of workflows were pretty good.

Ability to do automated deployments. It does what it promises: It helps you automate deployments. But, it works better for some application component types than for others.

I've found that the most valuable feature is the Server/Agent architecture. In most cases, once you install the agent onto a machine, you rarely (if ever) need to log on to the agent machine itself to diagnose issues with most scripted deployment tasks.

It has flexible deployment options, allowing us to model our components as we want and need, which is the most valuable feature we've found from our experience with it.

It helps us orchestrate enterprise applications that need to be coordinated.

Repeatable, reliable deployments from one environment to the next.