TrustRadius Insights
TeamCity has proven to be an invaluable tool for software development teams across various organizations. Users have utilized TeamCity in …
Overview
What is TeamCity?
TeamCity is a continuous integration server from Czeck company JetBrains.
Recent Reviews
Reviewer Pros & Cons
Pricing
N/A
Unavailable
What is TeamCity?
TeamCity is a continuous integration server from Czeck company JetBrains.
Entry-level set up fee?
- No setup fee
For the latest information on pricing, visithttps://www.jetbrains.com/teamcity/buy
Offerings
- Free Trial
- Free/Freemium Version
- Premium Consulting/Integration Services
Would you like us to let the vendor know that you want pricing?
Alternatives Pricing
What is Codemagic?
Codemagic is a developer's CI/CD tool for mobile app projects. Build Android, iOS, React Native, Ionic, Unity, and Flutter projects on Codemagic.Codemagic uses its own CLI tools under the hood to perform complicated tasks like code signing and distribution to the stores. These are open-sourced and…
What is Appsmith?
Appsmith is an open source framework to build admin panels, CRUD apps and workflows.
Product Demos
Sitecore CI/CD with TeamCity and TDS Demo
YouTube
Redgate DLM Demo (with TFS, TeamCity, & Octopus Deploy)
YouTube
CI/CD with JetBrains TeamCity | TeamCity Tutorial
YouTube
Demo Teamcity Build Project 2 (end)
YouTube
TeamCity Fundamental Tutorial for Beginners with Demo || Class - 01 || By Visualpath
YouTube
TeamCity demo - part 1
YouTube
Product Details
- About
- Competitors
- Tech Details
- FAQs
What is TeamCity?
A Continuous Integration and Deployment server that provides out-of-the-box test intelligence, real-time reporting on build problems, and boasts scalability. It is available both as an on-premises and a cloud-based version.
TeamCity Video
Getting Started with TeamCity
TeamCity Competitors
TeamCity Technical Details
| Deployment Types | Software as a Service (SaaS), Cloud, or Web-Based |
|---|---|
| Operating Systems | Unspecified |
| Mobile Application | No |
Frequently Asked Questions
TeamCity is a continuous integration server from Czeck company JetBrains.
The most common users of TeamCity are from Mid-sized Companies (51-1,000 employees).
Comparisons
Compare with
Reviews and Ratings
(58)
Community Insights
TrustRadius Insights are summaries of user sentiment data from TrustRadius reviews and, when necessary, 3rd-party data sources. Have feedback on this content? Let us know!
- Business Problems Solved
- Pros
- Cons
- Recommendations
TeamCity has proven to be an invaluable tool for software development teams across various organizations. Users have utilized TeamCity in their agile project management systems, specifically within the web development team, to streamline their workflow and enhance productivity. By seamlessly integrating their git repositories with their ticketing systems, users have been able to test and release code from the development environment to the production environment with ease.
The software's automation testing capabilities have been critical for both development and product support. With TeamCity, users have been able to evaluate and integrate numerous projects, pulling together over 300 components of their SaaS-based product. This has allowed them to schedule, execute, and generate reports for various types of automation testing, ensuring the quality and reliability of their software.
One of the standout features of TeamCity is its user-friendly interface. Users have praised how easy it is to navigate and manage builds and releases within the system. Additionally, TeamCity offers flexible templates through its templates, variables, and parameterization capabilities. This enables users to create common solutions, such as deploying MVC applications to IIS, quickly and efficiently.
TeamCity seamlessly integrates with several popular platforms like Git, Azure, AWS, and Visual Studio Team Services. This integration allows development teams to leverage existing tools in their CI/CD build process without any hassle.
While users appreciate the functionality provided by TeamCity, some have expressed a desire for more comprehensive deployment visualization features. However, this minor limitation does not detract from the overall effectiveness of the software.
Overall, TeamCity has become an essential tool for development teams looking to implement continuous integration and continuous deployment practices. By providing immediate feedback on code issues and enabling thorough testing before delivery to customers, TeamCity ensures a smooth and efficient development process. Its ease of configuration and implementation also makes it suitable for small organizations with multiple projects. With its ability to meet quality expectations by running automated unit tests and handling various environments, customers find great value in using TeamCity for their software development needs.
Reliable Performance: Many users have praised the product for its reliable performance. Several reviewers have stated that the product consistently meets their expectations and performs well without any issues.
User-friendly Interface: A significant number of customers have appreciated the user-friendly interface of the product. Numerous users mentioned that the interface is intuitive and easy to navigate, making it simple for them to use and understand all its features.
Great Customer Support: Several reviewers have expressed their satisfaction with the excellent customer support provided by the company. Users have reported positive experiences while seeking assistance from customer support representatives who were helpful, knowledgeable, and prompt in resolving their queries or concerns.
Long and Manual Upgrade Process: Many users have expressed frustration with the lengthy and manual upgrade process for TeamCity. They have found it to be time-consuming and cumbersome, requiring significant effort.
Lack of SaaS-based Solution: Several reviewers have mentioned their disappointment in the lack of a SaaS-based solution for TeamCity. This means that users are required to host and maintain a large server along with multiple build agents, which can be inconvenient and resource-intensive.
Weak Pipeline Visualization: A common concern among users is the weakness of TeamCity's pipeline visualization feature. They feel that it could benefit from improvements in terms of clarity and usability, as it currently falls short compared to other aspects of the platform.
- Users recommend TeamCity over Jenkins for its additional features, ease of use, and integration capabilities.
- They highly recommend TeamCity to IT companies and suggest that it is worth the investment for enterprise continuous integration.
- Users also recommend self-hosting TeamCity for small companies and mention its value compared to other services.
- Furthermore, they recommend taking advantage of the free trial, checking available plugins, and evaluating new major versions and security risks.
- Overall, users think TeamCity is a great product for build automation and continuous integration and consider it as one of the best CI tools available.
Attribute Ratings
Reviews
(1-18 of 18)Companies can't remove reviews or game the system. Here's why
- build automation.
- Deployment automation.
- unit test automation.
- dependency chaining.
- branch management.
- The UI is getting a bit dated but has taken on a serious overhaul in recent builds.
- Build configurations as code uses a push/pull mechanism which feels a bit clunky to use.
August 16, 2021
TeamCity, a must for every team
- User interface
- CD
- Pipeline
- Updates
- Customer service
August 13, 2021
TeamCity Delivers
- The ability to have different build processes and monitoring per branch/environment
- Run tests as part of the CI/CD pipeline
- Status monitoring across multiple projects with build histories
- When it is time to upgrade versions it is a cumbersome and time consuming process
- Some of the reporting could be better, no real visualizations of pipelines, histories, etc.
August 12, 2021
It gives you exactly what is advertised
- continuos integration
- continuos deployment
- running tests
- highly configurable
- fast when using several workers
- the UI can be improved
- Selection of build server for specific build
- We can add configurable properties
- One stop solution to create deployable package
- Initial and basic setup is easy
- It is not plug and play thing
- Need more specific configurations for smaller projects as well
- Online help is less available
- Basic implementation is easy but I think feature add on can be complex as it involve some language knowledge as well.
- See build status across many projects.
- It monitors multiple branches with different build processes for each.
- It's a useful unit test runner with test history and identification of flaky or problematic tests.
- Reading build output logs can be a pain at times, as they aren't really parsed; just long lines of output.
- When you have multiple projects and branches, determining what is currently building, what is pending, and what has failed can be difficult.
May 07, 2019
TeamCity above all else
- Build Automation: easy setup, one-click deployment, reliable use, great documentation/instruction.
- Tool Integration: great documentation, several existing examples, easy setup.
- Step tracking: clear pipeline display, easy to locate build logs, clear error messages.
- Desktop app: TeamCity is browser-based, and some may prefer having a desktop application to view deployments on.
- Tasteful UI: TeamCity has a simple, non-graphic UI that some may find boring or not as intriguing as some of the other options.
- TeamCity provides a great integration with git, especially Bitbucket.
- When a new code release (build) fails TeamCity has a great tool for investigation and troubleshooting.
- TeamCity provides a user-friendly interface. While some technical knowledge is required to use TeamCity, the design helps simply things.
- Upgrading TeamCity is a long and manual process.
- Java skills are needed to fully utilize TeamCity, although they are not necessary for basic or medium-level use.
August 03, 2018
My experience with TeamCity
- First and foremost is the ease of use
- Very good support for extending , plugging and scripting support to customize your needs
- Lightweight and accessible by browser.
- The Debug log is quite verbose and could be made more intuitive for troubleshooting build errors
- I would recommend improving it by some kind of integration with platforms like StackOverflow to aid developers and further improve the turnaround time for setting up successful builds
- There is still scope for improvement for build integration with projects in AWS and Azure cloud platforms.
May 25, 2018
TeamCity 7 Years On!
- A very friendly UI with good drill-down and "Pro" capabilities compared to all other CI systems
- A good reporting system that allows all our different types of automation tests to produce output for
- Fantastically simple to setup and configure
- The biggest and only issue we have is the lack of a SaaS-based TeamCity solution. Currently, we have to host and maintain 1 big TeamCity server and up to 15 build agents to build our 1500+ builds
- Build: Parameterization, Chaining from multiple sources, Templates, and general ease of use.
- Release: Works extremely well with "Build" process.
- Updates and Upgrades are simple, effective, and reliable.
- Pipeline Visualization: TeamCity's weakest area
- Fully customizable build process. Each step of the build process can be parameterized and customized to address specific needs of particular applications. This allowed us to easily convert from a custom VM-based environment to our current Docker-based environment.
- Manages large numbers of build agents seamlessly. This allows us to run multiple builds on many different applications in a most efficient manner.
- Build steps can be managed in an arbitrary manner, allowing some parts of the process to proceed in parallel while restricting others to depend on completion of all relevant steps.
- The customization is still fairly complex and is best managed by a dev support team. There is great flexibility, but with flexibility comes responsibility. It isn't always obvious to a developer how to make simple customizations.
- Sometimes the process for dealing with errors in the process isn't obvious. Some paths to rerunning steps redo dependencies unnecessarily while other paths that don't are less obvious.
October 25, 2017
Build with Confidence!
- Easy to set up. The UI is pretty easy to navigate and use. You can have your project up and running in minutes.
- Good integration with various build frameworks/methodologies. You can run standard Maven, Ant or Gradle builds with virtually no customization.
- Decent support for extensions via the plug-in mechanism. You can integrate with other popular tools such as Artifactory via plug-ins. Or write your own.
- Upgrade process can be a bit of a pain - have to do this manually on your server.
- It's easy for the new user to get lost in the UI. Although this is true for most systems that offer such a wide range of configuration options.
June 23, 2017
If you practice TDD, get TeamCity!
- GitHub integration is invaluable.
- Decent UI that allows many tasks to be performed with just a click.
- Detailed failure messaging, stack traces.
- There can be a lot of info to display so the UI can be a bit cluttered, especially if you have a lot of builds/apps going at once.
- Needs more intuitive way to kick off tasks or just even access settings.
- The detail of stack traces is nice, but it would be even better if it was cleaned up more and displayed in a better human-readable format.
April 14, 2017
TeamCity - My Go-To Build system
- Ease of configuration. Some build systems are difficult to get started on. TeamCity can be up and running quickly.
- Cross platform. TeamCity runs on most configurations, and a master can configure agents of other OS types, so it can build nearly anything.
- Price. It's free for limited use, so you don't need to pay until you ramp up and are using it a lot.
- The upgrade process could be smoother. Moving from one major version to another involves jumping onto all your servers and often causes some pain.
- Log formatting could be a little clearer, though that is true for almost all build systems.
March 31, 2017
TeamCity for the Win!
- TeamCity (via a Plugin) allows us to deploy directly to our Tomcat Staging Server, and via a different plugin, allows us to interface with our Docker Container to do a Zero Downtime deployment to our production system.
- TeamCity notifies the committing developer, as well as the project lead, if and when a build fails and for what reason.
- The User interface of TeamCity is also very intuitive and easy to understand.
- TeamCity's base plan is somewhat limited in regard to the number of projects, specifically build configurations, that you can have.
- It can take a little bit to get used to the Project Hierarchy structure of TeamCity, however, once understood, it can be extremely powerful for sharing properties and components between projects.
- Visual Studio integration is extremely tight.
- Supports a wide variety of test runners, first-class languages, and source control systems out of the box, and even more with plugins.
- The configuration system allows our build engineers to reuse build configurations and configuration components, the same way our developers reuse code.
- The entire thing is built in Java. Not a dealbreaker, but this does mean you need to know Java if you want to create a plugin for something TeamCity doesn't do natively.
- TeamCity does not seem to have any HA functionality, so no clustering, no active/passive. If your functional CI server dies, your build pipeline dies.
May 03, 2016
A easy and clean continuous evaluation tool.
Score 9 out of 10
Vetted Review
Verified User
- By default, the TeamCity installation comes with embedded Hypersonic SQL DB (HSQLDB for short). It is a good database in its own right and has its strengths in the situations where you would need a fast and tightly integrated in-process DBMS embedded into your Java application. But running a production server on HSQLDB is risky.
- TeamCity offers much better security than Jenkins from out of box installation itself.
- Browser-hosted interface serves as the primary way to administer TeamCity users, agents, projects, and build configurations. It provides project status and reporting information suitable for a broad range of users and project stakeholders. It provides build progress, drill down detail, and history information on the projects and configurations.
- In TeamCity a single branch can be built dynamically. When configuring a Git or Mercurial VCS root, you need to specify the branch name to be used as the default.
- TeamCity download was about 535 MB. Starting up TeamCity server on Mac is quite a large space.
- When compared with the existing continuous integration tools the number of plug-ins available is much less for TeamCity.