I find the TeamCity backend easily accessible. Users can login to the Linux servers that TeamCity is installed on and perform operations. Also I find the ability to template solutions using the meta runner a good feature as well as the user management feature. There is a display that shows which user made recent changes to a branch on GitHub, including the time the changes were made and the particular agent that ran the job. This is also a very useful feature. 

The metrics and audit available for projects, pipelines and  jobs come in handy when debugging.

One of the most beneficial features for us is the flexibility it offers in creating deployment steps tailored to different technologies. While we haven't used all of its capabilities extensively yet, we've found it easy to integrate with other solutions and flexible in handling various technologies. As for scalability, we've managed large-scale projects effectively by configuring different agents based on the project's scale and volume, which TeamCity supports well. Regarding stability and performance, while we haven't faced significant challenges, any issues we encounter are typically resolved by referring to the documentation, given our limited experience with TeamCity.

TeamCity is a very user-friendly tool. I didn't know about it five months ago, and I started digging into it. To be honest, it was very easy to start on it and to build my first build and to understand the concept or the methodology internally. 

It's very easy to configure as well. You can configure your build and the steps within in it in a very easy way since you can choose the syntax with how you will write your code. In comparison with Gitlab, Gitlab has its specific syntax, so you need to learn that; however, with TeamCity, you have the choice to choose the framework you want and so you can start easily. 

TeamCity has a remote build feature that we have used to support legacy products (that use compilers that cannot run on current OS versions).  Rather than having developers locked into an outdated PC for legacy support, we now only need to support a single VM that is configured as the build agent for the legacy product.  TeamCity provides integrations for Eclipse, but in our case, it worked better to create a Python script that provided the necessary interaction between SlickEdit and TeamCity.  Developers can make code changes on a current Windows or Linux system, and changes made locally are pushed to the build agent as a personal build.

We are also exploring capabilities of use of the "Report Tabs".  To ultimatly support FDA compliance concerns, I have a prototype of an HTML report being generated that includes CRCs, SCM URLs, SCM Revisions, etc for all items of a build chain.

TeamCity is very useful due to the fact that it has a strong plug-in system.

It's fantastic how simple it is to set up a pipeline. You don't need to be a technical user to understand the process and make it work and to create and build steps within the pipeline.

The most valuable features are:

• Build chains - it's really easy to set up all of your build dependencies
• Snapshot dependencies and triggers - you always build the correct code as a snapshot is taken at the moment you run the build chain (i.e. no unexpected check-ins are included in your build!)
• Templates - for setting standards and making the configuration easy and clean
• Meta runners - sharing code 

TeamCity is very stable, is easy to set up and maintain. Once everything is configured there is almost zero time needed to maintain it.

TeamCity's GUI is nice.

I spend less time scripting to get a build working and more time configuring TeamCity through its web-based front end.

• It's a very useful, intuitive tool to continuously deploy new builds
• A clean user interface
• It's very easy to use, even for non-build engineers
• Ability to run automated tests as part of the build process
• Easy to pinpoint issues with the detailed logs
• Easy navigation
• Useful to see how the build is progressing and how many tests are left to pass before the build is green

The ability to create Build Pipelines and create user groups are the two most valuable features.

The integration is a valuable feature. The solution comes with a great CI/CD flow. As we have our own personal server, we have our own account for each developer. When it comes to access to it's dashboard it can be integrated with a social control. We integrated with version control and did so with GitHub. It allows one to have repositories in a single place, so as to customize the whole desired flow for having an initial continuous integration of a working build.

• Centralized build automation
• Ability to embed powershell scripts for automated deployments
• Auditability of builds
• Unit tests
• Smoke tests
• Automated deployments

• General ease of use
• Quick start up time
• NUnit build runner

VCS Trigger: Provides excellent source control support. Able to customize a feature with the specific conditions we want. For example, if we wanted only a specific branch to trigger a build, we can do that. 

• Continuous integration
• Build templates
• Triggers
• Plugins
• Platform independence

We're using it for CI and automating build pipelines.

Features I really like:
Branch builds for Git repositories, shared resource locking, customization via plugins and meta-runners, and storing build configurations per-branch for Git code repositories.

• Ease of configuring complete build chains with the use of build templates
• Creating a single custom build runner that allows us to have a single entry point and filter steps by arguments for all our builds
• The ability to trigger subsequent builds in a chain based off of multiple types of triggers in a deterministic fashion

There’s loads of valuable features but PowerShell Runner is invaluable.

The support for cross-platform builds is very valuable, as is the flexibility in creating build steps. We love that we can include unit and integration tests as part of a build configuration! The plugin functionality is great too, and we couldn't live without the Octopus Deploy plugin.

The three best features are the following:

• Automated builds triggered on check-in
• Execution of unit tests with code coverage reports
• Automated deployment to various environments.

• Templates
• Meta-runners
• Plugins
• Multiple version control system support
• REST API support

• Good visualization of builds
• Easy configuration
• Good integration with IDE and JetBrains products

The most valuable aspect of the solution is its easy configuration. It also has multiple plugins that can be used especially for building .net applications.