Terms and Concepts

TeamCity Object Hierarchy

Projects are the topmost objects of the TeamCity hierarchy, and Root project is the main default project that contains all your custom projects and their subprojects. Each project serves for storing logically related build configurations and defining their common settings and parameters. Most often, a TeamCity project corresponds to a single software product or its specific version.

Projects can be configured manually or automatically, from a VCS repository. The settings of each repository used in a project are stored in a dedicated preset called VCS root. Besides VCS roots, a project contains other settings shared between its nested subprojects and build configurations: common parameters, clean-up rules, and many others.

Example of a simple object hierarchy in TeamCity:

A build configuration serves as a blueprint for running a certain job, or a build, based on the project's source code: either it is a compilation, testing, deployment — or all these stages one by one. A single build configuration can define settings that are used to run, for example, a nightly build or integration tests.
In certain cases, you may need to create multiple build configurations that differ only in few details. For this purpose, you can compose a build configuration template and use it to generate as many similar build configurations as needed. One of the popular use cases for using templates is testing and deploying software on different operating systems.

Each build configuration can have build features and build steps. A build feature is a piece of extra functionality available to a build: it could be a performance monitor, a reporting tool, or a support for pull requests. Some features are built in TeamCity and some can be obtained by installing external plugins. A build step is a logical stage of a build that is performed by a certain build runner. TeamCity offers a wide range of different runners: from testing tools to Docker integration.

Another important setting included into a build configuration is a trigger. There are multiple types of triggers in TeamCity. Their common purpose is to run a build automatically when a preconfigured condition is satisfied, thus establishing automatic continuous integration of a software product.

TeamCity offers all these granular objects so you can configure a build process as flexibly as possible. However, they would make more sense if you have the means to interconnect them with each other. For this purpose, TeamCity provides two types of dependencies between build configurations (that is between their builds):

• artifact dependency — for sending artifacts produced by one build to another build; an example of an artifact is a .jar application that is compiled by one build configuration and deployed by another.

• snapshot dependency — for assigning multiple builds to the same source revision (commit) so the same project files are used on all the building stages.

By connecting builds from different configurations or even projects with dependencies, you can create a flexible build chain. The TeamCity product itself is built with a complex chain of builds. It allows us to compile and test different software modules and deploy the resulting distribution files to the web.

Example of a build chain in TeamCity:

TeamCity Build Environment

The TeamCity server stores all the objects' settings, manages the build queue, monitors the state of running builds, and performs many other tasks.

A different piece of software is used for actually running builds — a build agent. You automatically get access to cloud build agents with your TeamCity Cloud server, but you can also install a build agent software on your own machines.

Learn More

To learn more about TeamCity, explore this Help further:

• The current Concepts section lists the main TeamCity objects and terms. Use it as a reference to learn about unfamiliar notions.

• If you are using TeamCity only for managing and viewing builds, make sure to read this section.

• If you have a Project Administrator or Server Administrator access, use the TeamCity Configuration and Maintenance section to learn how to configure projects or how to use the Administration panel and maintain the server. This section also contains information on configuration as code in TeamCity.

• Available TeamCity add-ins are described here.

• Under Extending TeamCity, advanced users can learn how to run build scripts for interacting with TeamCity, how to use TeamCity REST API, and more.

• If none of these sections answer your questions, try looking into Troubleshooting and How-to.

Additional information resources:

• Key features of TeamCity

• CI/CD Guide

• How to write custom TeamCity plugins

• TeamCity Roadmap