top of page


March 27, 2024

March 27, 2024:

TeamCity 2024.03 Is Here

In TeamCity 2024.03, we’re introducing some highly upvoted features, including optional artifact dependency, bundled HashiCorp Vault plugin, and supporting configuration cache for the Gradle build runner. Read on to learn what’s new.

Semi-automatic security updates

To keep you ahead of the curve in preventing and mitigating security issues, TeamCity 2024.03 now automatically downloads critical security updates. This approach helps to keep your system fortified against emerging risks and to swiftly tackle major vulnerabilities. Note that after an update is downloaded automatically, a system administrator still needs to approve its installation.

Bundled deal: the HashiCorp Vault plugin is now part of TeamCity

TeamCity has enjoyed integration with HashiCorp Vault via a plugin for a while now. Last year, we revamped the way this integration works, making it much easier to configure.

Now, starting from version 2024.03, we’re bundling the plugin with TeamCity, making it an integral component of any TeamCity installation.

Head over to our documentation to learn more about TeamCity’s HashiCorp Vault integration. 

Optional artifact dependency

Artifact dependencies enable your build configurations to retrieve files generated by other configurations or other builds in the same build configuration. To establish these dependencies, you have to define artifact rules outlining which files to download and their designated storage locations.

Previously, if TeamCity was unable to locate files matching these rules, a build would fail with the “Unable to resolve artifact dependency” error. 

Starting from version 2024.03, we’re introducing a more flexible approach to defining artifact dependencies. Now, you can configure the dependency to be ignored in the following cases:

  • The source build does not exist at all (this problem won’t be ignored if there are other, non-optional rules).

  • The source build does not have the required file.

  • The artifact rule is based on an archive and archive does not contain a required file.

If you’d like to share some feedback on the feature, please feel free to do so in this YouTrack ticket.

Trust but verify with untrusted builds

The Pull Requests feature allows you to review new code before adding it to the main codebase. You can choose to run builds from any contributors or only from those within your organization. The first option poses certain security risks, as it might expose your TeamCity server to harmful code. Meanwhile, the second choice restricts collaboration with a broader base of contributors.

Starting from version 2024.03, we’ve eliminated this trade-off between collaboration and security by introducing a new feature called the untrusted builds group. With untrusted builds, TeamCity can now differentiate between changes authored by trusted users and changes coming from an external source. 

With this new functionality, you can specify the conditions that determine how pull requests coming from external sources should be handled. You can also specify the list of approvers who will receive a notification in case such an untrusted build is queued.

The untrusted builds group currently supports GitHub and GitLab. Learn more about Untrusted builds in our documentation.

dotCover runner

JetBrains dotCover has been supported as a coverage tool for .NET-related projects in TeamCity for a while now. In version 2024.03, we’ve introduced a new build runner in the .NET Support plugin that integrates with the dotCover tool.

The new dotCover runner allows users to:

  • Run an arbitrary process under dotCover code coverage profiling to produce a coverage snapshot.

  • Merge snapshots between build steps produced by other .NET or dotCover runners.

  • Generate merged reports across a build chain for parallel tests and transform them into TeamCity’s custom reports.

The new functionality is useful for profiling arbitrary processes running .NET applications and combining reports between builds into one build chain.

Learn more about our dotCover support in TeamCity in our documentation.

.NET test retry in TeamCity

In version 2024.03, we’ve introduced an exciting new feature for the .NET build runner that provides the possibility of setting up retry policies for tests that failed in the same build. This feature will help address test flakiness and mitigate transient failures when running integration tests. 

If you’d like to share feedback on the feature, please feel free to do so in this YouTrack ticket.

Configuration cache support in the Gradle runner

Gradle’s configuration cache option significantly improves build performance by caching the result of the configuration phase and reusing this for subsequent builds. This allows Gradle to skip the configuration phase entirely in subsequent builds if there are no changes affecting the build configuration, such as modifications to build scripts.

Before version 2024.03, configuration cache support was not available in TeamCity’s Gradle build runner. With this release, we’re adding this functionality to TeamCity, enhancing the efficiency and performance of Gradle builds. Head over to our documentation to learn more about how to enable the configuration cache option for your TeamCity setup.

Git the ball rolling: enhanced Git submodule and large file storage (LFS) support

Git submodule is a repository embedded within another Git repository. It allows you to include and track an external repository as a subdirectory within your main project. This is useful when you want to incorporate external code or libraries into your project while keeping them in a separate repository with its own version control history.

Previously, in cases when the project and its submodules had different VCS roots, it was impossible to configure submodule authentication that was different from the main repository one. For LFS, you had to use the same credentials as used for the Git VCS root itself.

Starting from 2024.03, we’re introducing a new option that provides support for external submodules as well as external LFS in TeamCity. Now, you have the ability to incorporate parameter-based credentials into your TeamCity projects. 

As you check out source files, TeamCity seamlessly employs these credentials to access and retrieve the necessary files. Upgrade your project security and efficiency with this latest enhancement.

We look forward to receiving your feedback on the feature in this YouTrack ticket.

More control over Helix Swarm review comments

Previously, the Commit Status Publisher for Helix Swarm would comment on a review for every stage of the build (queued, started, succeeded/failed), causing potential spam issues, particularly with multiple tests running on a review.

Now, the Commit Status Publisher will only publish code review comments for the final “build finished” event. The possible comments are either: “Build was successful” or “Build failed“.

In addition to that, users will have the option to enable or disable the posting of code review comments via a checkbox in the build feature settings. This setting will also be available in Versioned Settings | Kotlin DSL for greater flexibility and control.

New parameter dialog

In the 2024.03 version, we’ve revamped the Add/Edit Parameter dialog, which you use when setting up build parameters in TeamCity.

In the updated dialog window, you can now opt for a new parameter type – Remote secret. You can select this type for parameters requiring values fetched from a remote source, such as HashiCorp Vault. This new parameter type also makes it easier for you to develop your own plugins.

March 4, 2024:

TeamCity 2023.11.4 Is Out

The new bug-fix release for TeamCity On-Premises is now available. In addition to important security fixes, version 2023.11.4 addresses several regular issues, including decreased TeamCity performance when the server cannot reach the domain, a broken build log when publishing caches is aborted due to an error, inability to process cross-node events in a multi-node setup, and more. Refer to the release notes article for the complete list of fixed issues.

As with other minor updates, TeamCity 2023.11.4 shares the same data format with all 2023.11.x releases, allowing you to easily upgrade or downgrade within these versions without the need to back up or restore.

We recommend upgrading to apply the latest improvements and security fixes to your TeamCity server.

Before you start, read our upgrade notes and use one of the following options to upgrade:

February 23, 2024:

TeamCity Roadmap Q1–Q2 2024

In 2023, we introduced a number of highly anticipated features to TeamCity. The long-awaited dark theme is now available in both TeamCity Cloud and On-Premises. We’ve also introduced agent terminals that allow users to open remote terminals on agent machines directly from the TeamCity UI. 

The Matrix Build feature in TeamCity now allows you to define a combination of parameters and corresponding values to create a matrix of build configurations. The Build Cache feature provides the ability to store files and share them between builds.

In this blog post, we’d like to shed some light on what we’re currently working on for TeamCity and what you can expect in the first half of 2024.

🚀 TeamCity Pipelines

TeamCity Pipelines is a new product that greatly simplifies the CI/CD process. The brand new visual pipeline editor provides a simple UI for working with CI/CD pipelines of any complexity. With TeamCity Pipelines, you can create, view, and modify your pipelines in one place and on a single page. 

We’re releasing the Beta version on March 18, 2024 – sign up for early access today!

Sign up for early access

☁️ TeamCity Cloud

A lot is happening within TeamCity Cloud! Here’s a quick overview of what we’re currently working on.

Options for smaller teams

We’re working on introducing new options tailored to smaller teams as part of our product roadmap. Our ultimate goal is to introduce a completely free plan for TeamCity Cloud that many developers and smaller teams will benefit from.

TeamCity Cloud on AWS Marketplace

TeamCity Cloud will soon be available for purchase on AWS Marketplace, providing users with more flexibility in accessing and utilizing our services.

TeamCity On-Premises will also become available on AWS Marketplace in the near future.

Docker Registry and other package storages

As part of our commitment to meeting user needs, we’re exploring the possibility of integrating Docker Registry and other storages like Maven Repository and npm Registry into our offerings. If this feature is of interest to you, please let us know via this contact form

Per-minute macOS build agents

We’re going to introduce per-minute macOS build agents to TeamCity Cloud. In addition to Windows, Linux, and ARM agents that are already available, you’ll also be able to run your builds on macOS. 

We’re going to offer Intel-based and Apple Silicon M1 build agents, providing teams building for iOS with greater flexibility, scalability, and cost-effectiveness.

🌤️ TeamCity Cloud Integrations

Out-of-the-box Microsoft Azure support

Our customers are increasingly willing to run build agents in the cloud because it lets them quickly increase the capacity of their delivery pipelines when needed. To support users migrating to Microsoft Azure, we are planning to improve and bundle the TeamCity Azure plugin.

Executor mode

We would like to support a common scheduler like Kubernetes, HashiCorp Nomad, or AWS ECS in order to run simple build tasks without the requirement to specify and maintain a build agent.

This will allow you to start setting up project build configurations without thinking about what workers will run your builds.

This approach will be handy for small and simple tasks that do not require local caches of VCS roots, dependencies, and similar elements. It will also increase resource utilization using schedulers. The schedulers can run multiple tasks in parallel on the same cluster node out of the box.

Build agent image builder

With TeamCity’s image builder, you’ll be able to build custom VM images of TeamCity build agents for various environments. This will speed up your builds using pre-configured VCS repositories, build dependencies, Docker images, and so on.

Learn more and vote for this feature

⛓️ VCS integrations

GitHub Checks support

(being actively developed)

TeamCity is gearing up to integrate GitHub Checks functionality, allowing users to specify and report on the checks to be executed within TeamCity for a specific repository. GitHub will subsequently trigger these checks for new commits and pull requests, and users can manually re-run them as needed. 

With this update, TeamCity will provide detailed check results, including granular information like failing tests. Additionally, we are exploring the possibility of implementing code annotation, supported by GitHub Checks.

Token management

(being actively developed)

TeamCity already uses expiring third-party tokens provided via OAuth or similar connections by VCS hosting services such as GitHub, GitLab, Bitbucket Cloud, Bitbucket Server/Data Center, and Azure DevOps. 

Our upcoming plan is to enhance transparency, enabling users to effortlessly re-issue or reuse existing tokens. Users will also have the flexibility to permit or prohibit token usage in specific TeamCity projects. Furthermore, we aim to make searching for and issuing tokens for use in Kotlin DSL settings easier.

Untrusted PR builds

(likely to be released soon)

This new suite of features will be especially important for those users who run builds on their public repositories, such as ones used for open source projects. TeamCity will be able to:

  • Detect builds running on less trusted sources (e.g. coming from a fork of a public repo).

  • Provide users with a pre-approval functionality for such builds.

  • Detect build configurations that could potentially trigger such builds automatically.

PR-driven build triggering

(being actively developed)

Currently, the Pull Requests build feature can be configured to internally extend the branch specification for a VCS root to include any pull/merge request branches within it. Some filters can be applied, for example, to make it so a build can only “see” pull requests targeted at a certain branch. This is not always an optimal solution, as sometimes users want to see all branches, but only automatically trigger certain ones. 

That’s why we are introducing an extension to branch filters that will allow users to filter branches by pull request attributes.

More expressive regexp-like branch filter syntax

(in design)

We’ve planned another improvement to branch filters – an alternative richer regexp-like syntax. This will allow users to maintain elaborate branch name conventions for their projects.

Simpler configuration of VCS hosting integrations

(in development)

Simplifying the user experience and making TeamCity features more discoverable are our main priorities. To do so for VCS hosting integrations, such as build status publishing and pull/merge request integration, we’re going to:

  • Suggest creating relevant build and project features when a project is created from a connection.

  • Consolidate as many of these integrations as practical on the TeamCity project level, with specific menu items appearing in the admin UI when such integrations are configured. For example, the GitHub menu item will appear if a project is created via a GitHub connection, and the respective admin UI page will allow you to control all GitHub-specific integrations within the project.

Custom Git LFS and submodule credentials

(likely to be released soon)

In some larger projects, users need to provide different credentials for a Git LFS storage or Git repository that stores submodules other than the ones used for the main repo. TeamCity will soon be able to support this functionality for TeamCity projects.

Agent-specific Git mirrors support

(likely to be released soon)

Sometimes with large Git repositories, it makes sense to keep a separate mirror closer to where TeamCity agents are hosted to improve performance. We’re planning to provide this functionality on an agent-by-agent basis.

Better support for SSH URLs for VCS roots created from connections

(being actively developed)

Currently, if a project, build configuration, or VCS root is created via a connection, TeamCity always uses an HTTPS-based fetch URL. Many users prefer to use SSH-based URLs, so TeamCity will support this. It will also allow users to upload a new SSH key or select one of the keys already accessible within the project.

💪 General TeamCity improvements

JetBrains Account login and the new license format

We want to allow you to manage your Server and Agent licenses transparently and flexibly via your JetBrains Account. We’re planning to simplify license management for TeamCity On-Premises customers by allowing them to manage their Server and Build Agent licenses through their JetBrains Account portal without having to generate and download with numerous offline license keys.

Making the path to Kotlin DSL in versioned settings repositories configurable

Currently, the Kotlin DSL doesn’t allow users to store settings for several projects in the same repository. Our goal is to provide more flexibility by allowing users to customize this configuration path according to their needs.

Learn more and vote for the feature

​​Option to run a build if the artifact dependency failed to download

Currently in TeamCity, snapshot dependencies offer the option to run a build even if the dependency has failed. 

We’re going to introduce similar logic for artifact dependencies. This functionality will be optional, giving users the flexibility to choose whether a failed artifact download blocks the entire build process or not.

Learn more and vote for this feature.

Speeding up server startup times on large installations

This TeamCity improvement, aimed at enhancing performance, focuses on optimizing the server startup time for large installations. 

Our goal is to reduce the time it takes for the TeamCity server to initialize and become operational in environments with extensive configurations or substantial data, ensuring a more efficient and responsive experience for users managing sizable installations.

Commit all configuration changes to a Git repository

The idea behind this feature is to commit and push every change (both project-related and global) to a specified Git repository. This repository can then be used to share configuration files between TeamCity nodes in multi-node setups.

This repository can also be used as an audit of all changes made to the TeamCity settings through the UI, Rest API, or versioned settings.

Learn more

Standalone build log service

In a multi-node setup, all nodes work with build log files stored in a shared data directory. Most of the time, one node “owns” the log file corresponding to a certain build. This node writes to the file while other nodes can only read it.

If a TeamCity node decides that the node that “owns” the log file crashed, but it is actually working normally, another node might start writing to the same log file and corrupt it.

We’d like to implement a standalone build log service that can be accessed by HTTPS from every node. The new approach will help us to eliminate the possibility of log files being corrupted as a result of two nodes writing to the same file.

Execute a dependency based on specific conditions

We’re working on the capability to execute a dependency in TeamCity based on a specified condition. This would allow users to set conditions for executing dependencies, providing more flexibility and control over the build process.

Learn more and vote for this feature

🔐 Security improvements

Stronger passwords in TeamCity

We’re working on a feature that will enable administrators to customize password security policies, defining criteria such as length and the inclusion of special characters and numbers. If a user attempts to log in with a password that doesn’t meet the requirements, TeamCity will require them to create a new password that does.

🏃‍♀️ Build tool integrations

TeamCity Actions

We’re going to design and implement TeamCity Actions – reusable, shareable packages of build runner configurations that can be used to simplify and streamline CI/CD processes. 

Dependency cache in build runners

TeamCity includes a Build Cache feature that allows caching specific directories between agents in a build chain within the artifact storage. However, users currently must manually manage the directories they want to cache.

We aim to simplify this process by automatically including the build system directories for which we offer integration within the cache. This improvement will streamline cache setup for users.

🕹️TeamCity for game development

TeamCity is one of the most popular CI/CD solutions for game development. TeamCity integrates with all major technologies and tools used in modern game development, including Perforce.

In 2024, we’re focusing on improving TeamCity’s Perforce integration and updating the Unity plugin that’s already available on JetBrains Marketplace. We’re also working on a new Unreal Engine plugin that will help game developers seamlessly integrate TeamCity with their video game development tools.

We’re going to add on-the-fly test reporting functionality for the Unreal Engine plugin.

🌸 TeamCity UI 

We’re constantly polishing and improving the TeamCity UI so that you feel at home when working with your CI/CD system. Here’s what we’re focusing on in Q1–Q2 2024.

Sakura UI: Problems tab

TeamCity provides an overview of current problems and investigations on both project and build levels. Users can review build configuration errors, failed tests, and problems that are being investigated, as well as check their assignee and status.

We’re reworking the UI to give our users a better overview of all issues and their statuses in a selected project. They can now be found under the common tab – Build Problems.

Client notification center

We’re looking into better ways to notify our customers about TeamCity updates and other important product-related issues. That’s why we’re going to introduce a number of features that will help our customers to stay on top of what’s happening in and with TeamCity.

What’s new notifications 

We’re going to introduce in-app notifications that will be displayed right within the TeamCity interface. The information about new releases and other important updates will be easily accessible here for all TeamCity users.

Notification center

There’s a lot going on in TeamCity that might require a user’s attention, from accessing the list of all assigned investigations to staying on top of failed builds. Until now, there was no unified way for TeamCity to notify users of any important changes related to their TeamCity instance.

With this in mind, we’re working on our new Notification Center, which will provide a quick and easy way for users to get updates regarding their account. Here, users will be able to review their assigned investigations and server health summary, among other things.

Users will also be able to configure which types of notifications they’d like to receive.

Health reports: New UI

When numerous server errors occur, TeamCity frequently presents them as extensive health reports that occupy the entire screen. Our goal is to enhance error reporting by making it more concise and compact.

Project administration and build configurations: New UI

We’re updating the project administration and build configuration UIs to be on par with the Sakura UI, the default for  TeamCity. Our ultimate goal continues to be reaching feature parity between the Sakura UI and the classic TeamCity UI.

🏗️ TeamCity infrastructure

Design Teamcity-Kubernetes operator

Operators are software extensions within Kubernetes that use custom resources for managing applications and their components. These operators follow Kubernetes principles.

We’re going to design and develop a Kubernetes operator for TeamCity and first adopt it for TeamCity Cloud. The operator will seamlessly integrate into TeamCity, providing out-of-the-box installation for any Kubernetes cluster.

Terraform Provider for TeamCity

We’re introducing the Terraform Provider for TeamCity, which uses a language familiar to DevOps professionals to streamline global server setup, user management, permissions, and project initiation.

Thanks to the Terraform Provider, managing the infrastructure for TeamCity projects has become much easier. We’re releasing the Beta version in Q1 2024 and will continue developing our Terraform Provider this year.

February 8, 2024:

What’s New in Datalore Enterprise 2024.1

Datalore Enterprise 2024.1 brings an improved experience working with interactive tables, the Vim text editor inside the terminal, multiple instance-wide configurations available directly from the Admin panel, better HTML rendering in cell outputs, as well as other improvements and bug fixes.  

Upgrade to 2024.1

Edit DataFrame cells in interactive tables

Forget about downloading CSV files to make a set of edits in a DataFrame. You can now simply edit the content of cells inside interactive tables and click Export to code to reproduce the result in the notebook. 

Drop duplicated rows action in interactive tables

We’ve improved the process of data cleaning with a new option to drop duplicated rows right from the interactive table’s interface. Choose between dropping fully duplicated rows or only rows with duplicated sets of columns and click Export to code.

In-terminal editor

The open-source text editor Vim now comes pre-installed with Datalore’s terminal, allowing you to create and edit files directly from the Terminal interface.

Updates for Datalore admins

Create instance-wide database connections 

Help your team get straight to work and streamline new user onboarding with instance-wide database connections. Configure company-wide connections from the Data tab in the Admin panel. Datalore users will instantly see the new connection in shared and home workspaces. 

Customize background computation time

Admins can now set up a custom background computation time via Admin panel | Computations | Background computations. Users will then be able to choose the new option for a single notebook or make it the default in Account settings.
Learn more about background computation here

Add new base environments from the Admin panel 

Datalore admins can now configure custom team environments directly from the Admin panel interface and specify the agent types, programming languages, and package managers these environments are available for.

Assign computation plans to groups of users from the Admin panel 

Managing users and their computation plans is now more convenient for admins. You can assign your internal plans to a whole group of users from the Admin panel. As always, you can control users’ individual plan assignments and override the group plan. 

Mount local host storage to machines in Docker-based installations

The mounting of local host storage to a notebook machine was previously possible only for Kubernetes-based deployments. Now customers with Docker-based installations can also programmatically configure access (including read-only and read-write) to the data they store on the same machines their notebooks are running on. Find more details in our documentation.

Separate domain configuration for rendering HTML in cell outputs

It’s now possible to configure a separate domain where HTML fragments from notebooks’ cell outputs will be securely rendered. This enables libraries like panel to function properly and allows you to embed YouTube videos through iframes without giving third-party websites access to users’ cookies and data. Learn more about how to configure a separate domain in Datalore’s documentation.

Other improvements and bug fixes

  1. Although data security and privacy have always been a top priority for us, we’re happy to announce that JetBrains Datalore has now officially obtained SOC 2 certification.

  2. Datalore reports will now be launched with only one session per user. The report state and calculations will persist through both page refreshes and when opening the same report in another browser tab, allowing for a consistent user experience and saving costs on computational resources. If a report gets updated by the owner, the report viewers will be notified accordingly. Loading the new version of the report will start a new session for the report viewers. 

  3. Build tools such as GCC and CMake are now part of the default Datalore agent image.

  4. cifs-utils is now part of the default Datalore agent image, allowing for straightforward CIFS storage mounting.

  5. We’ve improved the performance of notebooks with over 100 cells so that they now load more smoothly.

  6. It is now possible to reset the certificates for agent-server channel encryption directly from the Configuration tab in the Admin panel.

January 30, 2024:

TeamCity 2023.11.3 Is Here

The 2023.11.3 bug-fix update for TeamCity On-Premises is now out and available for downloading. This update includes a crucial security-related fix, and we urge you to install it as soon as possible. For the list of other issues fixed in this version, refer to our release notes.

As with other minor updates, TeamCity 2023.11.3 shares the same data format with all 2023.11.x releases, allowing you to easily upgrade or downgrade within these versions without the need to back up or restore.

We recommend upgrading to apply the latest improvements and security fixes to your TeamCity server.

Before you start, read our upgrade notes and use one of the following options to upgrade:

January 17, 2024: 

Watch our YouTrack Helpdesk Online Demo

In this livestream, we dive deep into YouTrack Helpdesk’s capabilities for support teams and internal service desks.

We’ve included an overview of the flow for several potential stakeholders:

  • Your external customers – reporters who submit tickets and get replies

  • Support agents who can benefit from a number of useful instruments to streamline their work

  • Any other members of your team who may be in the support processes along with other projects, or who may be interested in the reports or overview of the support state of things.

In the second part, we’ve included a demo for administrators of helpdesk projects showing them how to set up and organize the flow of your support projects, create signatures and answer templates, manage service-level agreements (SLA), automate support workflows, and more.

<Watch the webinar recording>


0:00 – Intro: YouTrack for various types of teams
1:03 – YouTrack Helpdesk capabilities, licensing, and pricing 

Your reporters’ flow
3:01 – Online demo starts: How reporters submit tickets and get replies
6:30 – Browsing the public knowledge base (for reporters)
7:40 – Accessing YouTrack so your reporters can submit tickets and get updates 

Tools for support agents
10:26 – Working with tickets
12:50 – Managing service-level agreements (SLA)
13:56 – Searching for and filtering tickets
15:27 – Ticket management tools: reply templates and agent signatures, revising comments, ticket visibility, internal and external comments, adding recipients to a ticket, linking and creating connected tickets

Helpdesk project administration
26:00 – Helpdesk project creation
27:33 – Managing roles in helpdesk projects
29:35 – Setting up the fields and creating custom fields 
30:12 – Setting up ways to collect tickets – emails and online forms
33:28 – SLA policy configuration
35:59 – Workflows for support processes
37:19 – Overview of the created helpdesk project

Jan 30, 2024
Feb 8, 2024
March 4, 2024
Feb 23, 2024
Jan 17, 2024
July 4, 2023
Aug 24, 2023


July 4, 2023:

JetBrains Academy’s New Projects and Topics: July Update

If you’re learning Python, JavaScript, Kotlin, or Go and you’re interested in adding unconventional projects to your developer portfolio, such as a traffic light, browser game, or account service, we’ve got you covered!

But that’s not all. We’re also introducing 66 new topics across programming languages, algorithms and data structures, system administration and DevOps, and computer science fundamentals. This will allow you to further expand your programming knowledge.

Now, let’s take a closer look at what’s new.

Python (data science, machine learning)

🆕 Python project: Traffic Light (Beta). Hard

In this project, not only will you create your own traffic light app, but you will also gain valuable skills in multi-threading, exception handling, class inheritance, and implementing the circular queue data structure.

🆕 Data science project: Random Forest from Scratch (Beta). Hard

Dive into the implementation of one of the most popular ensemble algorithms, Random Forest. You’ll have the opportunity to build the entire algorithm from scratch using numpy and test it on the titanic dataset from sklearn.

🆕 NLP project: HyperSearch Engine (Beta). Challenging

Build your very own search engine using the TF-IDF algorithm. Your program will be able to highlight the target word and provide context around it.

🆕 Django project: Regex Tester (Beta). Challenging

Harness the power of regular expressions by creating a tool for testing regexes. In this project, you’ll develop a simple regex tester that can store the history of tests, allowing you to tame the complexity of regular expressions.

🆕 Topics: 


Last month 5 Python projects got high scores for their usefulness, clarity, and fun from our users. These projects have now been released from Beta and are ready for you to explore:


Frontend (HTML, CSS, JavaScript)

🆕 Project: Site for Marathon (Beta). Easy

Discover the power of iframes in web development as you learn to seamlessly embed external content within your web pages. Explore the techniques of absolute positioning and z-index to precisely position elements on your page. Gain proficiency in working with images and adding subtle animations to enhance the dynamism of your web page.

🆕 Project: Who Wants to Be a Millionaire (Beta). Medium

Create a browser game while acquiring essential skills in web development. Dive into the world of browser events and learn to effectively handle them, enabling seamless interactivity within your game. Work with JSON objects, allowing you to efficiently store and manipulate game data, and develop your game logic using JavaScript.

🆕 Topics: 


We’ve also released the Postprocessor project from Beta, with improved content and functionality.


🆕 Project: Bulls and Cows (Beta). Medium

Challenge yourself by creating an advanced version of the classic code-breaking game “Bulls and Cows”. Begin by recreating the original version of the game and then elevate it to new heights with your innovative additions and enhancements.

🆕 Spring Boot project: Account Service (Beta). Challenging

Master the Spring Security module. Gain a solid understanding of user authentication and authorization, allowing you to ensure the utmost security for your applications. Learn how to register security events and familiarize yourself with the latest information security standards for web applications, ensuring your projects meet modern requirements.

🆕 Topics:


The Blockchain and Cinema Room Manager have also been released from Beta.


🆕 Project: File Type Analyzer (Beta). Challenging

Files come in a variety of formats, often indicated by their names. Even if the file type has been manually changed or removed, information about the type is still embedded within the file. In this project, you’ll build a tool that extracts information from files to determine their type. Experiment with various algorithms and observe how different algorithms impact the tool’s speed.

🆕 Topics: Synchronization with channelsContext cancellation and timeouts


🆕 Topics: Hashing the problemExternal resources

Algorithms and structures

🆕 Topics: Dynamic programming: another approachCryptographic hash functionsEdit distanceCaesar cipherVigenère cipher

System administration and DevOps

🆕 Topics: 



🆕 Topic: Unified types


🆕 Topics:


That wraps up this month’s offerings! We hope you’ll enjoy exploring these exciting projects and topics to enhance your programming skills.

Note that projects marked as Beta are still in the early stages of testing. If you’re interested in checking out Beta projects on the platform, make sure the Beta-tester feature is enabled in your profile settings.

If you have any questions or if you would like to share your feedback, feel free to leave a comment below, contact us at, or share your thoughts with us on Twitter or Facebook.

Enjoy learning!



July 6, 2023:

Space On-Premises 2023.2 Is Out!

Do you strive for complete control over your data while developing software?

You’ll be glad to know we’ve just released Space On-Premises 2023.2, a more accessible version with new simplified installation options and other useful features.

With the new AWS one-click installation option, you can now quickly and easily run Space on the AWS cloud. You can also use Docker Compose as a stable installation with the expanded Docker Compose configuration steps that we’ve added in this version.

To help improve your productivity, Space On-Premises 2023.2 adds a number of new features, such as powerful IDE-inspired navigation, issue time tracking, the ability to store build artifacts and cache project dependencies, support for Rust packages, the quick option to create issues directly from code snippets, and more.


Read this article to learn what’s new in the 2023.2 version, and see an overview of the available installation options to find one that suits your team best.

Full Article

July 12, 2023:


IntelliJ IDEA 2023.1.4 is Here!

We’ve just released IntelliJ IDEA 2023.1.4 with several valuable fixes.

You can update to this version from inside the IDE, using the Toolbox App, or using snaps if you are a Ubuntu user. You can also download it from our website.

Here are the most notable fixes included in v2023.1.4:

  • We fixed the issue with missing custom code style settings and they are now correctly preserved by the IDE. [IDEA-318457]

  • The Copy Reference action for files in non-java modules works as expected and copies the path from the content root. [IDEA-316752]

  • The @jakarta.validation.constraints.NotNull annotation is now interpreted correctly during nullability inspections. [IDEA-323547]

  • Starting up the IDE no longer fails with the “CannotActivateException: Address already in use: bind” error. [IDEA-323836]

  • The IDE now has full Wildfly 28 support. [IDEA-320285]


To find out more information about the issues resolved, please refer to the release notes.

August 16, 2023:

Increase Your Productivity With TeamCity Documentation Examples for the Kotlin DSL

TeamCity offers the ability to define project settings and configure CI/CD pipelines programmatically with the help of the Kotlin DSL. 

To help you take advantage of the Kotlin DSL’s capabilities and simplify the build configuration process, we’ve created extensive Kotlin DSL documentation. It comes with examples that you can simply copy-paste directly into your code base.

How the Kotlin DSL documentation works

Every TeamCity server has its own Kotlin DSL documentation, which is automatically curated to match the TeamCity version and any plugins installed on the server. If you install a new plugin, the documentation compiles again, providing you with relevant examples.
You can also refer to the general Kotlin DSL documentation, which is available in the TeamCity docs.

Accessing the Kotlin DSL documentation from IntelliJ IDEA

The Kotlin DSL documentation is available right from IntelliJ IDEA (both Ultimate and Community editions). You can access it by going to Maven Tool Window | Download Sources and Documentation.

Another way to access the Kotlin DSL documentation directly from your IDE is to run the mvn -U dependency:sources command.

The documentation’s context and examples change when you click on an entity (for example, a build step or a trigger). The information is displayed either in a popup window or in the panel on the left, depending on the settings you’ve selected.

There are a few different ways to open the Kotlin DSL examples from your IDE:

  1. Pressing F1 on Mac or Ctrl + Q on Windows. Refer to this section of the IntelliJ IDEA documentation for more details.

  2. Clicking on the name of an entity (such as a build step or a command). The examples will open in the menu on the right-hand side of the window.

  3. Simply hovering over an entity to access the in-line information window.

How this feature is helpful

Using Kotlin DSL examples can save you time when configuring your pipelines as code. The examples also make it easier to discover all of the things you can do when configuring builds, in addition to helping you identify the scenarios that TeamCity can support.

Working with the Kotlin DSL examples can be a particularly great option when you are just getting started, as they provide a solid foundation on which to build your understanding of the Kotlin DSL.

TeamCity also provides you with an option to view your settings as code with the help of the View as code button, which is available on the build level. This displays your settings as code that you can copy and paste to your codebase.

If your project can’t be configured via the UI and you’d still like to experiment with the View as code feature, consider setting up a sandbox project on your TeamCity server. It will give you a chance to play around with different TeamCity features and see how they look in the Kotlin DSL.

Further resources

If you’d like to learn more about using the Kotlin DSL for TeamCity, here are some additional resources that you might find useful:

Over to you

Do you have any questions or comments about how we can improve the Kotlin DSL examples and documentation? We’d love to get your feedback! Feel free to share it in the comment section below. 

Happy building!

August 24, 2023:

How To Choose a CI/CD Tool: A Framework

There are plenty of options available when it comes to selecting a CI/CD tool for your organization. A direct feature comparison on third-party websites like G2 can help you get a solid understanding of a tool’s core functionality. 

However, you might still find it challenging to understand whether a tool is capable of meeting your specific requirements, how easy it is to use, or how compliant it is with your industry regulations.

In this blog post, we offer general guidelines for selecting an appropriate CI/CD solution and delve into how TeamCity fits into this framework. We hope it will help you make an informed decision when choosing the best tool for your organization.

Choosing the right CI/CD tool for your needs and goals

The needs for a CI/CD solution can vary greatly between teams, and a tool that serves one team perfectly might not be as suitable for another.

Here, we suggest seven main factors to consider when choosing a CI/CD solution for your team.

  1. Development workflow. The solution should integrate smoothly into your development workflows without requiring you to write too many custom scripts or plugins.


  3. Pipeline configuration. The tool should offer a flexible setup for environments, security checks, approvals, and more to allow the proper flow of artifacts and dependencies between build steps.


  5. Feedback and analysis. The CI/CD solution should provide comprehensive feedback on multiple levels, from error messages to infrastructure performance, to ensure fast problem resolution and an uninterrupted delivery process.


  7. Scalability and maintenance. Moving from one tool to another can take months of work, which makes it very important to use a solution that will cover all of your future needs from the outset.


  9. Security. It’s critical to prevent malicious actors from stealing your source code, hacking into your infrastructure, or compromising the end product.


  11. Cost efficiency. When evaluating a CI/CD solution, it’s not only crucial to look at the price of a license or a subscription but also the operational and maintenance expenses.


  13. Usability and support. Every developer, even without prior experience in continuous delivery, should be able to understand how their project is built and deployed, and how to effectively use the tool to deliver changes faster.


  15. Hosting model. Depending on your company’s needs, you might consider using a cloud or self-hosted solution. Both options have their advantages, so the final choice entirely depends on your specific needs.

All modern solutions offer essential features, such as Docker supportconfiguration as code, or automatic building of pull requests. For smaller projects, the differences between these solutions may not be as significant.

However, as your team grows and your workflows become more complex, it becomes increasingly difficult to set up the pipelines correctly and ensure they function as intended. In such cases, your experience with different CI/CD tools may vary greatly.

💡See also: Best Continuous Integration Tools for 2023 ‒ Survey Results

Source: Developer Ecosystem Report 2022

Development workflow

When evaluating a continuous integration tool, it is important to understand to what extent the tool can be customized to your workflow, and to what extent your team will need to adjust its processes to the tool. Consider the following aspects:

Diversity of your change workflows

Your team may require the ability to build every pull request, run the pipeline when someone commits to a specific branch, or trigger a build when a particular user changes files within a particular directory.

Sometimes, you may need to run the build pipeline without committing changes to the repository to ensure that you never commit broken code and avoid negatively affecting your team members’ efforts.

💡See also: Pre-Tested Commit: No broken code in your version control

Your code may be distributed across multiple version control systems (VCSs) of different types or live in a monorepo. You may need to rebuild and redeploy the application whenever an external dependency, such as a Maven package or a Docker container, is updated.

By carefully evaluating a CI/CD tool’s support for your specific change workflows, you can ensure that the tool is a good fit for your team and minimize the need for changes in your own processes.

Docker and non-Docker workflows

While Docker can provide a convenient and efficient approach to building many types of applications, there are situations where running on an actual OS is necessary. For instance, if your application relies on integration with a hardware component that cannot be accessed from a Docker container, you may require an OS-based workflow.

Similarly, a Docker-based workflow may be insufficient for your team’s needs if your software requires interaction with an OS, such as when developing a system driver or a Windows service.

When choosing the best CI tool for your team, evaluate your specific project requirements and consider the advantages and limitations of both approaches.

Team maturity

Teams just beginning their journey with continuous integration may be more flexible in adapting their workflow to fit a particular solution. Thus, tools with fewer configurable options may provide a simpler and more streamlined user experience.

In contrast, highly skilled teams that precisely understand their needs may find all-inclusive DevOps platforms limiting, as these solutions might not offer the required level of flexibility and customization.

Ease of migration

When selecting a new CI/CD tool, ease of migration should be one of the key considerations. In many cases, it may be simpler to migrate to a standalone solution rather than to a complete DevOps platform. This way, users can migrate in batches, you’ll have to write fewer manual integrations, and it will minimize disruption to your development workflows.

Organizational aspects

It’s vital to consider the culture and policies of your organization, particularly if teams are encouraged to select their own development tools.

Keep in mind that some team members may resist changes to their workflow, especially if they are comfortable and familiar with their current tools.

Development workflow support in TeamCity

TeamCity is an excellent fit for the following workflows:

  • Support for multiple VCSs.

  • Ability to run CI/CD processes without committing.

  • Granular control of changes (filtering by branches, usernames, file masks, etc.).

  • Trigger-defined parameters.

  • Comprehensive API to integrate with other tools.

While it may be tricky to choose between the streamlined experience of a platform and the flexibility of a standalone tool, the good news is that one doesn’t necessarily prevent you from using the other.

Since it’s common for teams to use multiple CI/CD tools concurrently, you might as well use a combination of a standalone solution and an all-inclusive DevOps platform as long as there’s proper integration between the two.

Pipeline configuration

Every team has its own unique workflow and requirements, which makes using a customizable solution that fully meets your needs vital. Here are the different types of pipeline configuration that you might consider when choosing a CI/CD tool.

UI and code-based configuration

Some tools offer a UI-based configuration approach that provides an easy way to get started and maintain the setup, as the pipelines can be configured without any special knowledge.

All modern tools support configuration as code, which gives you a versioned configuration history.

Many tools use YAML configurations, which provide a very straightforward way to automate the building and testing of simple apps. However, managing YAML files can become increasingly difficult as the team and infrastructure become more complex.

For large-scale projects, it might be more effective to configure CI/CD using a fully-fledged  programming language, which allows using loops, conditional statements, and other language constructs. In addition, it makes it easy to write the configuration code in an IDE and take advantage of its refactoring and debugging features.

Workflow customization

Customization is a critical aspect of selecting continuous integration and continuous delivery software, as it allows teams to create pipelines that match their specific build and deployment workflows.

Depending on the trigger event, such as a code commit, a dependency update, or a scheduled trigger, teams may want to customize the build environment, scope of testing, Docker image tag, and other pipeline components.

If you need to execute specific steps sequentially on the same build agent (for example, you might want to start a Windows service and then run a build on the same system), the chosen tool should provide the ability to set this up exactly as needed.

Environment configuration

When selecting a CI/CD tool, it is essential to consider the level of customization it provides in terms of environment configuration. Specifically, teams should be able to choose the build environment that best fits their requirements, whether using Docker containers, cloud build agents, bare metal servers, or hybrid options.

💡See also: TeamCity’s Build Infrastructure Features

Pipeline optimization

As discussed in the Scalability section above, there are various optimization techniques that can help teams to complete builds faster and shorten the feedback loop.

One key optimization technique is the ability to cache dependencies, which can help minimize build times by avoiding having to download and install dependencies every time a build is run. Additionally, the ability to reuse build artifacts can further reduce build times, as previously-built components can be reused in subsequent builds.

Parallelizing tests across multiple build agents is another effective way to optimize pipelines in large projects. By spreading tests across multiple build agents, teams can reduce the time required to run all tests, helping to shorten the feedback loop and ensure that issues are identified and addressed more quickly.

💡Parallel tests revolutionized how we develop and test TeamCity. Our own integration tests have become over 10x faster, dropping from four hours to about 20 minutes.

Artifact management

Producing and propagating artifacts is essential to any CI/CD pipeline. Artifacts allow your builds to “communicate” and pass the data from one build to another.

By choosing a tool that can store artifacts, you can store the data produced by your builds for further analysis and debugging.

Feedback and analysis

The primary purpose of CI/CD is to shorten the time it takes to receive feedback on the changes you make to your software. The most actionable feedback is the one that is directly tied to specific code changes and provides information about the status of builds and deployments, as well as changes in performance and quality metrics.

When evaluating a CI/CD solution, the following aspects must be considered:

Analysis of build results

CI/CD solutions should provide a detailed analysis of build results, including information on failed tests, build times, error logs, and other key metrics. This information should be easily accessible and presented in a way that allows developers to identify and address issues quickly.


It is important for tools to provide trend analysis capabilities, allowing teams to track changes in build and deployment performance over time. This can help teams to identify patterns and trends and proactively address potential issues before they become more serious.

Performance monitoring

To identify bottlenecks and resolve issues that affect the efficiency of the CI/CD process, it is critical to be able to profile the performance of build agents and identify the need to provision more resources to the build infrastructure.

Performance monitoring in TeamCity

VCS and issue tracker integration

By integrating with the version control system and the issue tracker, a CI/CD tool opens more ways to provide feedback.

Flaky test detection

It’s important for a continuous integration tool to be able to analyze and detect flaky tests. To shorten the feedback loop and speed up your development process, look for a tool that can identify flaky tests for you and highlight them in the test results.

Scalability and maintenance

Software projects tend to grow in size and complexity. A reliable CI/CD system must be able to handle this growth and keep pace with the growing number of pipelines, builds, users, roles, and workflows.

To ensure that your team is never held back, the system should be able to efficiently manage resources and be equipped with monitoring and maintenance tools to resolve any issues that arise quickly.

The following factors will help you understand the level of scalability required for your team.

User management

In small-scale projects, it’s usually sufficient to have basic role-based access rules that define who can trigger builds, view build results, or modify the pipeline configuration. Large teams require more advanced features, such as LDAP integration or single sign-on (SSO) support, two-factor authentication, project hierarchy, granular permission management, approval workflows, and audits.

💡See also: TeamCity’s User Management Features

Pipeline optimizations

As the frequency of commits and the complexity of workflows increases, it becomes important to utilize the resources of the CI/CD efficiently. This can be done by reusing build artifacts and minimizing the number of unnecessary rebuilds, reordering build queues, parallelizing tests, and via other similar features.

Project templates

The larger your organization is, the more you will benefit from using project templates. By standardizing typical workflows, you can significantly reduce the effort required to create and maintain pipelines, improve collaboration between teams, prevent misconfigurations, and increase the security of your CI/CD pipelines.

In this case study, Gearbox, an award-winning game development company, shares how they were able to streamline their CI/CD processes and standardize their CI/CD practices with the help of TeamCity’s reusable project templates.

Read the complete case study

Performance and fault tolerance

As the number of projects grows and the demand for computing resources increases, it becomes more challenging to scale the build infrastructure and mitigate the risks of potential downtimes.

Typical requirements of large companies include automated provisioning of build agents (such as by integrating with cloud platforms) and the ability to organize build agents in pools for easier management.

Enterprise-level solutions pay a lot of attention to high-availability features, such as the ability to run multiple application servers in a clustered environment and smart load balancing.

Maintenance and upgrade

To identify and resolve issues in the CI/CD setup, administrators should have the monitoring and logging tools and be able to increase resources, implement caching mechanisms, or update artifact retention policies when needed.

Special attention should be given to upgrading the solution. Some tools rely on external plugins so heavily that upgrading them without breaking existing functionality may be difficult or even impossible.

A scalable CI/CD solution may not be crucial for small teams and projects with limited complexity. However, as the size of the team and the complexity of the project increase, it becomes one of the most critical aspects of the software development process.

How TeamCity supports scalability

TeamCity can support projects of any size, including projects with a vast amount of dependencies. It can scale automatically during periods of high load. One instance of TeamCity Server can stably work with 1,000+ build agents.

💡Read more: Solving Build Server Scalability Issues

Security features

Security is a major consideration for any software development process, and it is especially critical for CI/CD, as CI/CD tools are given trusted access to sensitive data and systems.

When evaluating a solution, look at the security features from two main perspectives:

  1. Security of the service. With new threats and vulnerabilities emerging every day, the solution must ensure that potential attackers can’t get access to your source code, secret keys, build infrastructure, or build results.

  2. Security of the end product. Many CI/CD tools allow integrating security checks into the build pipelines to ensure that the resulting software doesn’t have vulnerabilities that can be exploited.

Some teams tend to prioritize speed and efficiency over security, which can lead to shortcuts and neglect of security best practices. Integrated platforms generally provide an easier way to secure CI/CD at the cost of “vendor-locking” you into their ecosystem and workflows.

💡Check out our whitepaper “9 Ways To Prevent a Supply Chain Attack on Your CI/CD Server” for additional security tips.

Cost efficiency

As pipelines become more complex and team sizes grow, the price of a license or subscription can become less important compared to other factors that can affect the effectiveness of the CI/CD system:

  • Statistically, by reordering the build queue and minimizing redundant builds, teams can save at least 30% of the build time and associated costs.

  • The more tools and services your CI/CD supports out of the box, the less the chance you’ll have to write and maintain custom scripts and external integrations. This can drastically affect maintenance costs.

  • Additionally, most teams have peak periods (usually during release times) when any failures of the continuous integration tool can significantly impact the company’s business. This is one of the challenges that can hardly be evaluated without having actual experience with a particular CI/CD solution. Still, it is possible to understand how it handles such issues by reading reviews and feedback from other teams regarding work on similar tasks.


Ultimately, the total cost of ownership of a CI/CD solution depends on your team’s specific needs and requirements. As a general rule, it is prudent to consider the following factors:

Integration costs

Integrating CI/CD with version control systems, issue trackers, build and test frameworks, deployment automation systems, and other tools can be very time-consuming and expensive.

Maintenance costs

Every CI/CD solution requires allocating resources for running regular security audits and keeping the underlying infrastructure up to date, diagnosing and eliminating bottlenecks. In many companies, supporting these processes requires an entire team.

CI/CD efficiency

If your builds are constantly sitting in the queue and you are not getting rapid feedback, this defeats the whole purpose of a CI/CD solution. Such features as dynamic scaling in the cloud, re-using of builds, and test parallelization significantly impact developer efficiency in large companies.


To achieve efficient and productive software development, it is essential to have a feedback loop that is not only timely but also actionable. When a build fails, developers should quickly identify the root cause of the issue and see a clear path to a resolution. Often, there is an observable time between being notified of a build failure and fully understanding what needs to be fixed – and this is where a reliable tool can provide immense value.

By analyzing build logs and providing precise information about the issue, the best CI/CD tools can help developers fix any issues quickly and confidently, leading to faster feedback loops and increased overall productivity.

Factors that reduce TeamCity’s cost of ownership:

  • Licensing costs

  • Infrastructure costs

  • Integration costs

  • Maintenance costs

Usability and support

Finding the optimal balance between functionality and user experience is a constant challenge for vendors of CI/CD solutions. When evaluating software usability for your team, you should consider the following factors:

UI consistency

As the size of projects increases, it becomes increasingly essential that your CI/CD provides the required functionality without adding unnecessary complexity. When evaluating a solution, ensure that the most critical features are provided by the vendor, not developed by the community.

An intuitive user interface is vital in a CI/CD solution because it helps developers easily and quickly understand and use the solution, even when working with complex processes.

Example of TeamCity’s UI

External plugins can often introduce navigation issues, feature an unresponsive interface, have conflicting terms and icons, exhibit difficulty adapting to different screen sizes and devices, and lack proper documentation. Regardless of how experienced your team is, an inconsistent user interface will always result in reduced productivity.

“One of the competitors had a very unfriendly UI. The feeling that people should have when they come into a CI/CD system is that it is very sturdy; it won’t break when I try to do anything in it. I think TeamCity has a very well-polished UI. You have confidence that it is a well-working system when you navigate it.”
– Steve Fortier, Lead Release Engineer, Gearbox

Read the complete case study



If a CI/CD system supports accessibility features such as screen reader compatibility, keyboard navigation, and high contrast mode, it’s usually a good indicator that it provides a good experience in general.


Documentation and support


Comprehensive documentation, tutorials, videos, and a supportive community can be essential for effectively using a CI/CD tool. As a rule of thumb, the longer the solution has been available on the market, the higher the chance that you will be able to resolve problems and obtain answers to your questions.




Depending on the specific requirements of your team and the workflow you want to implement, you may need to integrate your CI/CD with external tools. This experience can vary widely depending on the maturity of the API, the availability and quality of its documentation, and how rapidly it changes between versions of the software.


Hosting model



CI/CD solutions can be roughly divided into two categories – cloud and on-premises options.

The cloud option takes the burden of maintaining and scaling the CI/CD processes off your team’s shoulders and allows you to build the pipeline in the cloud.



Meanwhile,  on-premises solution will enable you to host your CI/CD behind the security of your firewall, complying with the strictest security regulations and requirements.



Final thoughts


Choosing a CI/CD tool for your organization depends on many factors. In this blog post, we’ve provided you with the key factors you might want to consider when researching the best fit for your team or organization.



Feel free to share your questions or comments in the section below. We’ll be happy to answer them.



Happy building!

September 6, 2023:

JetBrains Academy’s New Projects and Topics: September Update

September is a month of change and excitement, and we’re here to make it even more inviting with our latest updates. Our team has prepared four new Python projects and more than 90 new educational topics.

Let’s look at these updates in more detail.


🆕 Project: Rhythm Store (Beta). Medium.

In this project, you will learn the basics of SQL, testing your skills with complex queries using an e-commerce database: tracking orders, products, employees, and other vital data. If you love to deal with complex databases, this project is for you.

🆕 Project: Text-Based Adventure Game (Beta). Hard.

Explore the history of gaming!
Back in the day, video games – like Colossal Cave Adventure –  were mostly text-based adventures with no fancy graphics. In this project, you’ll get to make a text-based game with your own story, learning how to utilize “if” statements, array lists, dictionaries, and loops. You will also learn the basics of file handling.

🆕 Project: House Classification (Beta). Hard.

Welcome to our Amsterdam real estate challenge, in which you’ll predict house prices using machine learning with loads of categorical data. Learn how to use different data encoders and dive into master data manipulation and decision tree algorithms, the key to unlocking the secrets of Amsterdam’s housing market!

🆕 Project: Bike Shop. Challenging.

You’ll create a web application for a bike shop that allows customers to customize their bikes and checks whether the necessary parts are in stock. In this project, you will learn about general Django concepts and master Django ORM (object-relational mapping). As a result, you’ll create an application with separate pages for each object in a database – bikes, in this case.  Ready for a ride? Let’s go!

🆕 Topics: 


Furthermore, we’ve released the Random Forest from ScratchDatabases for Sales, and Nobel Laureates projects from Beta with improved features and functionality for learners.


🆕 Topics: 


Additionally, the JSON Database project was released from Beta.


🆕 Topics: For loop statementIf/else conditional statementJump statementsSwitch conditional statementWhile loop statementFunctionsOverloaded functionsParameters and arguments in functionsReturn in functionsArithmetic operatorsComparison operatorsIncrement and decrement operatorsLogical operatorsOperator precedence and associativity rules


🆕 Topics: Greedy algorithmsConvert text inputIntroduction to HashSet


🆕 Topic: CRUD operations – update


🆕 Topics: 


Additionally, the URL Shortener project was released from Beta.

System administration and DevOps

🆕 Topics: ExpressionsMultiple stage buildingRunning a pod with a simple applicationUtilization of resources in a pod


🆕 Topic: Probabilities as frequencies

Projects marked as Beta are still in the early stages of testing. If you’re interested in checking out Beta projects on the platform, make sure the Beta-tester feature is enabled in your profile settings.

That’s it for this month! 

We hope that you find these updates valuable and that they will enhance your learning experience. As always, we welcome your feedback and suggestions, so please don’t hesitate to get in touch with us at, or share your thoughts with us on Twitter or Facebook.

Happy learning!

September 18, 2023:

Introducing the Space integration for Jira Cloud

We believe that well-organized processes are crucial for building software efficiently. With this in mind, we're taking an issue-centric approach to software development that seamlessly integrates coding into the pipeline, boosting developer productivity and reducing friction.

As an extensible platform, Space aims to provide a similar issue tracking experience for both external issue trackers and Space issues. Today, we're happy to take the first step and introduce the Space integration for Jira Cloud, which allows you to:

  • Preview Jira issues in Space

  • Create Jira issues from Space

  • Automatically link Jira issues to commits and merge requests

For more information and to install the integration, head over to this page

October 13, 2023:

updates and improvements to YouTrack

Knowledge Base Updates

This release includes a handful of features designed to make your knowledge base experience even better.



Inline Comments

With inline comments, you can now annotate specific parts of text from articles in the knowledge base. This lets you express your thoughts and ask questions related to the highlighted content. You can also use this feature to start and resolve threaded discussions directly in an article.

PDF Export

A new option lets you export articles as PDF files, which means you can share content from your knowledge base anywhere you like, online or off.

Article Statistics

Starting from the 2023.2 release, you can track how many people are viewing and linking to your content.

Helpdesk Improvements

Following the initial release of helpdesk projects in YouTrack 2023.1, we listened to your feedback and added some valuable new features to enhance your support experience.




Tickets in helpdesk projects now include the option to add reporters and other users as CCs. This means you can keep all concerned parties up to date on every response and interaction.

Creating Tickets for Other Users

Helpdesk agents can now create tickets on behalf of any other user in the system. New search queries have been added to help agents and reporters find these tickets.

Other Enhancements



Zero Inbox for the Notification Center

You now have the ability to mark reactions and mentions as read, which means you can see an empty feed when you have read all your notifications.

Updated Workspace Settings for Lite UI

The workspace preferences that let you customize the positions of the panels for custom fields and links in YouTrack Classic are now available in YouTrack Lite as well.

Smart Suggestions for Search Queries

We've improved the logic behind the auto-completion for search queries to de-prioritize suggestions that are not likely to return matches. This means you should always see suggestions that are relevant to your current context as you refine your search criteria.

Invitations for New Users from Project Settings

YouTrack now sends invitations to new users who are added to a project team using their email address. This helps you create accounts for new teammates directly in the project settings.

Okta Synchronization

We've updated the built-in authentication module for Okta to let you sync group memberships and custom attributes on a set schedule.

New Options for Opening the Command Dialog

A new option in the Apply Command dialog in YouTrack Lite lets you choose whether to open the dialog using a standard keyboard shortcut or by pressing any key. This means you can limit this action so you don't trigger it accidentally.

Turkish Language Support

Thanks to contributions from our community translation project, you can now start using YouTrack in Turkish.

This new language option is available at the global level or as a per-user preference.

Discontinued Features



Custom Shortcut Schemes

We have removed support for custom keyboard shortcut schemes. This means that administrators can only select the default shortcut scheme or the alternative scheme for Slavic-language keyboards.

Jabber Notifications

Given the ongoing decline in popularity compared to other messaging platforms, we have decided to discontinue support for notifications over Jabber (XMPP).

MSI Distribution

Starting from YouTrack 2023.2, we no longer distribute the application as a Windows Installer package. System administrators will need to use another distribution to upgrade an existing MSI installation. We recommend that you upgrade your installation using our Docker Container.

Integration with Upsource

As JetBrains has discontinued technical support for Upsource, we have also dropped support for integrations between Upsource and YouTrack.

October 25, 2023:

What’s New in Datalore Enterprise 2023.5

Datalore Enterprise 2023.5 is out! The new version enables you to conveniently open recent notebooks from the editor, features database connections using custom JDBC drivers, Snowflake, and BigQuery OAuth authentication methods, and brings a number of other improvements and bug fixes.

New Open notebook dialog in the editor

You can now conveniently open recent notebooks right from the editor. Head to the Main menu, click on File, and choose Open. From here, you can either search for a particular notebook or pick one from your Recent activity list.

New Open notebook dialog in the editor

Custom JDBC driver support

The latest update allows you to connect to databases not natively supported in Datalore Enterprise with custom JDBC drivers. Get in touch with your Datalore administrator and direct them to the Admin panel | Miscellaneous. From there, they can use the New custom database driver dialog to select and upload the necessary driver files from the local system.

Custom JDBC driver support in Datalore

Snowflake and BigQuery OAuth authentication methods

Securely connect to Snowflake and BigQuery with OAuth directly from Datalore Enterprise. Select this option within the authentication methods available in the New Snowflake / BigQuery connection dialog. You can choose whether this authentication works for just one session (without tokens) or for multiple sessions and users (with tokens).

Snowflake and BigQuery OAuth authentication methods in Datalore

Other improvements and bug fixes

  • Datalore now offers table name parametrization to keep your data secure from SQL injection via an unsafe parameter filter in the query syntax.

  • Sessions for each data source are started proactively (as soon as the machine starts up) to make sure all SQL cells used in a report are executed in a timely manner.

  • We introduced an Empty trash button to clear all deleted items.

  • We fixed the issue with multiple Git repos having different authentication keys.

  • We added a Note field to the Ban user confirmation dialog to provide reasons for the action.

  • Dynamic height is now enabled for more than one cell in a row in the Report builder.

  • Users are now notified of interactive report recalculations without delays.

Not yet leveraging Datalore inside your team? Talk to our experts to discuss how Datalore can benefit your data workflows.

November 10, 2023:

Power Up Your Pipelines with New Agent Types Available in TeamCity Cloud

We’re introducing new types of JetBrains build agents to TeamCity Cloud. These new, more powerful agents can handle more intense builds, helping your team to build projects of any complexity.

The new agent types include new ARM Linux machines and the latest versions of the Ubuntu and Windows operating systems.

What are build agents in TeamCity?

In TeamCity, build agents are distributed agents responsible for executing the actual build and deployment processes defined in your build configurations. These agents perform tasks such as compiling code, running tests, packaging applications, and deploying artifacts.

Build agents in TeamCity enable parallel and distributed builds, which are essential for large and complex projects.

In TeamCity Cloud, you can use self-hosted build agents or take advantage of JetBrains-hosted agents. The latter are maintained and configured by JetBrains. They are started on-demand as soon as each new build needs to run.

Thanks to JetBrains-hosted agents, you can start building quickly, as you don’t need to spend time on initial agent setup and maintenance. We are now extending this fleet of agents to ensure more user scenarios are covered.

New operating systems

Previously, TeamCity Cloud offered JetBrains-hosted agents on Ubuntu 20.04 and Windows 2019. In the next two years, these OS versions will come to the end of their standard support timeline (January 2024 for Windows Server 2019 and April 2025 for Ubuntu 20.04).

In order to prepare for the end of this support and meet the growing demand for the latest long-term support versions, we’re now introducing agents on: Ubuntu 22.04 and Windows 2022. The complete list is as follows:

  • Windows: Windows-Server-2022-Small (2 vCPU), Windows-Server-2022-Medium (4 vCPU), Windows-Server-2022-Large (8 vCPU), Windows-Server-2022-XLarge (16 vCPU).

  • Linux: Ubuntu-22.04-Small (2 vCPU), Ubuntu-22.04-Medium (4 vCPU), Ubuntu-22.04-Large (8 vCPU), Ubuntu-22.04-XLarge (16 vCPU).

The set of preinstalled software and hardware specifications remain the same as for previous versions. See the documentation for further details.


There are two pricing options available for JetBrains agents:

  1. You can pay for the exact number of build minutes that an agent is occupied.

  2. You can reserve an agent for a month and pay in advance.

Both per-minute and per-month prices haven’t changed and are the same as for the older versions of agents of the same size.

For instance, the price for Windows-Server-2022-Small is the same as for Windows-Small – 20 credits per minute or 150,000 TeamCity Cloud build credits monthly.

Feel free to reach out to us if you have any questions.

Sep 6, 2023
Sep 18, 2023
Oct 13, 2023
Jul 12, 2023
Aug 16, 2023
July 6, 2023
Oct 25, 2023
Nov 10, 2023
Nov 28, 2023

​ November 28, 2023:

TeamCity 2023.11: Matrix Build, Build Cache, and More

In TeamCity 2023.11, we’re introducing numerous highly anticipated features that make configuring builds easier. These include Matrix Build and Build Cache. 

We’ve also enhanced integrations with Git hosting platforms, including GitHub, GitLab, Bitbucket, and Azure DevOps. 

Furthermore, the improved TeamCity UI makes working with agent terminals even easier. The Favorite Agent Pool and Agent Parameter tabs provide a concise way of accessing important agent-related information. The completely reworked UI for the Amazon EC2 and S3 plugins simplifies working with these Amazon services.

Read on to learn more about what’s new.

Matrix Build

TeamCity is happy to introduce a long-awaited feature: Matrix Build. Matrix builds are dynamically created separate builds with various configuration parameters.

The Matrix Build feature in TeamCity allows you to define a combination of parameters and corresponding values to create a matrix of build configurations. Each combination of parameter values generates a unique build configuration. The matrix build is then made up by several multiple builds that run separately.

For example, suppose you have two sets of parameters: one for the operating system (Windows, Linux, or macOS) and one for the browser (Chrome, Firefox, or Safari). You can now define a matrix of builds with a complete set of these parameter combinations. This will result in a total of nine build configurations (three operating systems multiplied by three browsers).

Matrix builds are useful when testing software across different configurations, such as operating systems or browser versions. By defining a matrix of build configurations, you can run the same set of tests across multiple parameter combinations within one build configuration, making it easier to review results and fix compatibility issues.
Learn more about how to set up matrix builds in our documentation.

Build Cache

In version 2023.11, we’re also introducing build caches to the list of build features in TeamCity. This feature provides the ability to store files and share them between builds.

In CI/CD, using single-use build agents is considered best practice. However, this approach imposes certain problems. With single-use build agents, heavy libraries need to be downloaded every time the build is run, slowing down the build time and causing delays. It also wastes resources by using unnecessary traffic from external locations such as Maven Central or the npm Registry.

Caches help you optimize your CI/CD runtime by downloading the files that your project depends on and then reusing them again within the project. After an initial build run, subsequent builds will run faster as you won’t have to download the same files again. This way, the build can start more quickly and will consume less traffic.

Caches are helpful in the following use cases:

  • Speeding up dependencies that resolve in both generic and most used package managers, including Maven, npm, and .NET.

  • Caching heavy computations, such as compilation cache.

  • Asset caching.

With dependencies restored from cache, the system will only need to download new or updated dependencies as opposed to downloading everything from scratch every time the build runs. Customers who use short-lived cloud agents will also benefit from this new feature. 

Learn more about build caches in our documentation.

Manually scheduling builds in custom run dialogs

TeamCity now gives users the ability to manually schedule a build to run on a specific day and time. As opposed to scheduling the build to run on a regular basis, any user who has the permissions to start a build can set the trigger to run it at a specific time.

This unique feature gives users more flexibility in deciding when exactly they want to run the build. This will help users avoid spending unnecessary time waiting to start the build. 

Learn more about build scheduling in our documentation.

Using snapshot dependencies stored in VCS

There used to be a significant limitation when using settings from the VCS. Changes in snapshot dependencies were ignored, and TeamCity would continue using the snapshot dependencies from the previously applied settings.

Starting from this version, TeamCity can load custom snapshot dependencies, VCS roots, and checkout rules from settings stored in a version control system. You now have even more flexibility to edit versioned settings and create custom branches with settings that significantly differ from those in default or stable branches.

Read more about this new feature in our documentation.

Integrations with Git hosting platforms

TeamCity offers seamless integrations with Git hosting platforms, including GitHub, GitLab, and Bitbucket (both Cloud and Data Center).  

Let’s take a closer look at what’s new.


Simplified GitHub App creation via manifest

In version 2023.05, we introduced a new type of connection to GitHub. Instead of utilizing the traditional OAuth-based access to repositories, you could use GitHub Apps. 

Starting from version 2023.11, you can establish these connections more efficiently, eliminating the need for manual configuration and new app registration in GitHub.

To do this, go to Add Connection and select Automatic from the dropdown menu in the Creation Mode field. Add your GitHub server URL or organization’s name and let TeamCity do the rest.

Learn more about GitHub Apps from our documentation.

Refreshable tokens

You can now issue refreshable access tokens for GitHub App connections using the Commit Status Publisher and Pull Requests build features, as well as on the GitHub Issue Tracker settings pages.

Bitbucket Cloud

With this release, we’re enhancing Bitbucket authentication in several ways. 

Now, in addition to app passwords and VCS root credential authentication types, TeamCity also supports refreshable and permanent access tokens as an authentication method for the Pull Requests build feature for Bitbucket Cloud.

Learn more in our documentation.

Bitbucket Server and Bitbucket Data Center

The Pull Requests feature can now use refreshable OAuth tokens to access repositories on Bitbucket Server or Bitbucket Data Center.

Learn more from our documentation.


Ignoring draft merge requests

A merge request in GitLab can be marked as a draft, which is the same as the draft status of pull requests in GitHub and Azure DevOps.

In version 2023.11, we added the functionality to ignore draft merge requests in the Pull Requests build feature.

Refreshable tokens for authentication

The Commit Status Publisher and Pull Requests features that target GitLab repositories can now also use refreshable application tokens to pass authentication.

Azure DevOps

TeamCity now supports OAuth tokens in the configuration of the Commit Status Publisher and Pull Requests build features for Azure DevOps.

Azure DevOps users can now also choose refreshable tokens from configured TeamCity connections.

Amazon EC2 updates

We introduced several Amazon EC2 features in TeamCity Cloud 2023.07. With this release, we’re also adding them to TeamCity On-Premises.

Specifying multiple subnets and instance types for EC2 cloud images

Previously, when setting up an EC2 cloud image in TeamCity, you could only select a single subnet for your virtual private cloud. 

In most cases, however, users didn’t want to be restricted to just one subnet. Running an instance in a specific region instead of a particular subnet would make more sense, as this way, TeamCity can choose the most appropriate subnet in terms of available resources.

A combination of running instances in the scope of a region and using a few instance types gives you more reliable instance usage. TeamCity can now take the first option from the available combination and run an instance. If the selected subnet or instance type runs out of capacity, TeamCity will automatically switch to the second available option, and so on.

This update also simplifies the setup of cloud profiles. You no longer need to set up multiple cloud images just to achieve a regional scale and instance type diversity.

In addition, you can also select several instance types and security groups in TeamCity.
Share your feedback on the feature in this YouTrack issue.

Configuring agent image to launch an instance from the last created AMI with a given tag value

In TeamCity 2023.11, we’re also introducing the ability to configure the build agent to launch an instance from the last created AMI with a given tag value.

A custom image to run your build agents can be referenced by a unique AMI ID and reused by multiple build configurations.

Previously, all of these cloud images would have to be updated manually if this custom image were updated, as the AMI ID would also change. If there were many cloud profiles that used the same image, and you updated it, you’d have to go and manually update the ID in each of those cloud profiles.

You can now reference the most recently created AMI with a given tag value or combination. This means that, if you update the image, it will automatically be used by all compatible project and build configurations, saving a significant amount of time on maintenance.

Support for EC2 Mac instances

If you use EC2 Mac instances, you have to run builds on a specific bare metal machine. TeamCity now uses tags to find a dedicated Mac host suitable for running instances.

Thanks to this feature, your builds will run uninterrupted as long as there are available machines within the indicated tags.

Have a question or comment? Feel free to leave your feedback in this YouTrack issue.

Running AWS EC2 Spot Instance build agents using a Spot placement score

TeamCity has long supported Amazon EC2 Spot Instances, allowing you to place your bid on unused EC2 capacity and use it as long as your suggested price exceeds the current Spot price.

With the 2023.11 release, TeamCity now supports AWS Spot placement score. This feature will help users who use AWS EC2 to spin up build agents in a more stable and predictable manner.

Spot placement score comes in handy when you need to:

  • Scale and relocate Spot Instance compute capacity in a different region.

  • Identify the most optimal availability zone.

  • Find an optimal combination of instance types to meet your Spot Instance capacity needs.

New UI for the EC2 plugin

With the 2023.11 release, we’re rethinking our approach to setting cloud profiles and images. 

The credential configuration section was always visible on top of the page. This obstructed the view and made it cumbersome to make changes.

Given how often cloud images are updated, we’ve redesigned the Cloud Profile interface to make it easier to create new profiles and edit existing ones.

S3 plugin update

With version 2023.11, we’re introducing the following enhancements to the Amazon S3 plugin:

  • Intuitive and streamlined UI designed with both Amazon S3 buckets and S3-compatible storages (such as MinIOBackblaze B2, and others) in mind.

  • Hassle-free setup with a reduced number of settings. All connection-related properties are now retrieved from a selected AWS connection. The AWS region is automatically obtained from the selected bucket.

  • The ability to disable integrity verification that TeamCity carries out by default for all custom S3 storages.

Learn more about Amazon S3 and S3-compatible storages in TeamCity.

UI improvements

Favorite agent pools

We now provide users with the ability to mark certain agent pools as favorites and access them from a unified place. This comes in handy when a user needs to access the agent pools that they are responsible for.

To add an agent to the Favorite Agent Pools list, simply hover over the agent pool and click the star sign. Users can mark only those agent pools they have access to as favorites. 

Reworked agent terminal UI

Agent terminals are a unique TeamCity feature that provides a convenient and quick way to get direct access to an agent machine by opening a remote terminal directly from the TeamCity UI. It is supported on Linux, Windows (with PowerShell), and macOS. 

With the help of the agent terminal, you can investigate what exactly is happening on the agent.

Starting from version 2023.11, you don’t have to switch tabs in order to open agent terminals. They now open on the same page in the TeamCity UI. 

You can also open the terminal for several agents at the same time. They will be conveniently displayed as tabs.

Revamped Agent Parameters tab in Sakura UI

Ever since Sakura became the default UI for TeamCity, our goal has been to reach full feature parity between the classic and Sakura UIs.

In TeamCity Cloud 2023.07, we introduced the revamped Agent Parameters tab for TeamCity Cloud users. Now, the updated UI is available for On-Premises users as well!

Cloud integrations

Build agents with bundled JDKs

TeamCity agents require a Java environment to start. Previously, when you installed a build agent, you’d also need to install a particular Java version required by that agent. 

Starting from version 2023.11, it’s possible to create distributions of TeamCity agents that come with customized JDKs. These distributions provide the convenience of installing both an agent and its necessary JDK in a single operation.

To create a custom agent distribution, navigate to Administration | Agent JDKs and add a new JDK option. You’ll need to specify the platform, the architecture, and a link for TeamCity to download this specific JDK.

When a new option is added, TeamCity will start building your custom agent distribution. You can download custom agent and JDK bundles by clicking Install agent | Full distributions on the Agents | Overview page.

Thanks to this new feature, you can customize the Java version used on a specific agent, thus customizing the agent environment. This simplifies the complex build agent installation process and brings us one step closer to shipping the Build agent image builder feature that we’re actively working on.

Learn more about installing TeamCity agents here.

Prioritizing cloud images

TeamCity can work with multiple cloud images to start compatible agents. Public cloud providers charge for virtual machines differently, depending on the region of allocation. Different regions also provide different capacities. 

As a result, agents in certain regions might become exhausted, while others might still have capacity but are more expensive.

TeamCity now allows prioritizing some cloud images over others. You can set up TeamCity to always run agents in the cheapest regions with a fallback option to more expensive ones.

This can help your team significantly save financial resources while still getting the best result from your agents.

Enhanced integration with Perforce Helix Swarm

Starting from version 2023.11, the TeamCity Perforce Helix Swarm publisher for the Commit Status Publisher build feature can be integrated with custom workflows that already exist in your Swarm setup. In addition, the feature no longer requires the credentials of users with administrator access.

It’s now possible to set up the integration without using Swarm administration-level credentials in TeamCity. The updated integration also allows including gates based on TeamCity checks into custom workflows.

Learn more in our documentation.

Other Perforce integration improvements

You can now reuse a prepared volume with Perforce sources checked out during a build at a known revision according to a client mapping or stream.

It is now also possible to specify a custom Perforce workspace name to be used by TeamCity during the agent-side checkout. To do this, set the configuration parameter vcsroot.<VCSRootExternalID>.p4client. This parameter can also be set during a bootstrap step via the setParameter service message after the start of the build.

For the full list of new features, please check out our documentation.

December 13, 2023:

Discover the Power of JetBrains AI in YouTrack for Free

The power of generative AI is now freely available to teams using YouTrack! AI Assistant, powered by JetBrains AI, is available in YouTrack 2023.3. It helps you generate summaries for content in tasks, articles, and support tickets, provides a localized summary of content in any language, and composes replies and comments for you.

You can now also use text recognition to copy text from images and search for images containing specific text.

More enhancements have been included to improve your work with tasks, issue lists, and articles.

AI Assistant in YouTrack

AI Assistant is powered by the JetBrains AI Service, which transparently connects you to a sophisticated large language model (LLM) and enables specific AI-powered features inside YouTrack. Free credits are now available to use with JetBrains AI for our customers, so we encourage every team to check out the opportunities that generative AI can bring to your daily collaboration on projects.

Effortless summaries with AI Assistant

How often do you open a task or an article and see a description and discussion so long that you need to scroll up and down? AI Assistant will give you an at-a-glance summary of the content in project tasks, Knowledge Base articles, and helpdesk support tickets. It analyzes the title, description, and all of the comments, no matter the length, and provides a summary of what’s going on that you can read in seconds.

You can replace what was originally written with the generated summary if it better conveys the meaning.

When you want to speed up things further, you can briefly draft a task description and ask AI Assistant to suggest an alternative summary so that a clear and concise title is added in just two clicks.

For teams working in several languages or with customers across the globe, a summary can play an even more critical role in speeding up communications. AI Assistant provides summaries in the language you set in your user preferences. Even when the content in question is in another language, it can give you a translated, condensed version of the task or article in no time at all.

Let AI Assistant generate comments for you

When you’re ready to join the discussion, AI Assistant offers you ways to compose a reply. AI Assistant will provide you with suggestions on how to reply to the comments based on the content. Choose the topic for the reply that you want to start with, and AI Assistant will create a suggested comment for you.

Then, you can either use the suggested text directly or modify it before publishing. In many cases, you can get the desired results much faster than typing your reply from scratch.

AI Assistant will work in the language of the previous comment in the discussion so that your message won’t get lost in translation.

Use the power of generative AI for free

All YouTrack Cloud customers, including small teams using YouTrack for free and YouTrack Server customers with active subscriptions, now have access to free credits for AI-powered features. These credits will be replenished weekly so your teams can have constant access to the power of generative AI.

In 2024, we plan to offer additional credit purchases for more extensive team needs. Meanwhile, YouTrack administrators will have access to AI credit usage statistics to understand how the use of AI features is distributed across your teams.

The era of generative AI in YouTrack is only just getting started. We’ll continue our work to make AI Assistant even more powerful and expand the AI actions to give you the help you need in your YouTrack activities. Stay tuned!

Use JetBrains Grazie to write even faster

If you can’t wait while we’re working on bringing you the next batch of powerful generative AI features in YouTrack, you can participate in the free JetBrains Grazie Early Access Program!

Grazie is a writing assistant also powered by JetBrains AI. It helps you improve text that you compose directly in your web browser, meaning you can easily use it with YouTrack.

You can get real-time proofreading, autocompletion, definitions, and rephrasing right in your browser for seamless and effective communication. Grazie is now available as a free extension in Google Chrome and Safari (beta) and speaks several languages, including English, German, French, Spanish, Russian, Korean, Chinese, and Japanese. These features will help you communicate faster in YouTrack, JetBrains IDEs, and other platforms.

Learn More

Text recognition from images

YouTrack can now automatically extract text from image attachments. When you add an image – a screenshot, a photo of a document, or any other image containing text – YouTrack quickly turns it into editable and searchable text with ease.

You can copy text from images for further use. When you search for text, YouTrack also includes images containing any matching text.

Due to certain technical restrictions, this feature is unavailable to some YouTrack Server installations, specifically ones that have started from .zip archives. We hope that YouTrack administrators will consider planning the switch to Docker – our Support team always on hand to assist.

Pinned Comments in tasks, articles, and support tickets

One of the most-voted feature requests from our public tracker has been released, so we hope this relatively minor feature improves how your team collaborates in YouTrack.

You can now highlight important parts of the discussions in tasks, articles, or support tickets by pinning comments. They help you draw attention to information or answer frequently asked questions. Pin comments to the top of the discussion to help readers not to overlook the crucial parts.

The use cases are numerous. The results of a lengthy debate can be pinned so that all issue followers can quickly get an understanding of the resolution. For support services organized with YouTrack Helpdesk, a pinned comment in a ticket with a helpful answer can save your team time when working on similar cases in the future. For articles in the Knowledge Base that document any aspect of your project, a pinned comment can also save future readers time and effort.

Other Enhancements

This version also comes with a freshened-up interface for viewing tasks in YouTrack Classic and greater control over the look and feel of the issue views – you can now resize the fields panel and manage the density of the layout.



Check out the Release Notes for the full technical details and a comprehensive list of bug fixes and improvements in this release. For full details on configuring the latest features, visit the documentation.

If you use YouTrack Cloud, you’ll automatically be upgraded to YouTrack 2023.3 in accordance with our Maintenance Calendar. If you have an active YouTrack Server subscription, you can download YouTrack 2023.3 today. If you don’t already have a license, you can use the free trial to test out the new version before you commit to buying! For more information about the licensing options available for YouTrack, please visit our Buy page.

December 19, 2023:

New in TeamCity: Remote Parameters and Updated HashiCorp Vault Plugin

When configuring a CI/CD pipeline, you may need to obtain secrets from a third party. This could be necessary to connect with an external service crucial for your pipeline or to secure the deployment of your application with the required confidential information.

You can store all of these secrets as secure parameters in TeamCity. However, you might need an extra layer of security. For these purposes, people use remote secret management tools such as HashiCorp Vault.

TeamCity has offered an integration with HashiCorp Vault via a plugin for a while. Recently, we’ve updated the way that the plugin is configured, making it much easier and quicker to use. 

Let’s take a closer look at what’s new.

What is HashiCorp Vault?

HashiCorp Vault is a tool designed to manage secrets and protect sensitive data within modern IT infrastructures. It provides a secure and centralized way to store, access, and distribute secrets, such as API keys, passwords, certificates, and encryption keys.

The goal of HashiCorp Vault is to ensure that applications and systems have the necessary credentials and secrets while maintaining a high level of security and compliance.

What’s new: An easier way to set up the connection

TeamCity’s HashiCorp Vault plugin allows you to connect TeamCity to Vault, request new credentials when a build starts, pass them to the build script, and revoke them immediately when the build finishes. 

Previously, you had to use a complex syntax in order to set up the connection between TeamCity and HashiCorp Vault.


The old way of setting up the HashiCorp Vault connection

We’ve added a new parameter type – Remote – that is available right from the Parameter tab.


The new way of setting up the HashiCorp Vault connection

Once you select this parameter type, you can then choose the Remote Connection Type, which in our case is HashiCorp Vault Parameter. The query doesn’t require the % prefixes that it did previously. You can just type in the query and test the connection.


The query now functions without prefixes

Using the Kotlin DSL

You can either configure the connection via the UI or use the Kotlin DSL. For the Kotlin DSL configuration, you can click on the View as code button in the TeamCity UI and review the code.

You can either configure the connection via the UI or use the JetBrains Kotlin DSL. To get a better understanding of what the Kotlin DSL configuration looks like, you can click on the View as code button in the TeamCity UI and review the code. When using the Kotlin DSL, you’ll have to specify the name and the query:

params {

hashiCorpVaultParameter {


namespace = "accessKeysVault"

query = "aws/data/access!/AWS_SECRET_ACCESS_KEY"


hashiCorpVaultParameter {

name = "env.AWS_ACCESS_KEY_ID"

query = "aws/data/access!/AWS_ACCESS_KEY_ID"


param("env.AWS_DEFAULT_REGION", "eu-west-1")

Please refer to our documentation to learn more about setting up the HashiCorp Vault plugin.

How is this update helpful?

Instead of using sophisticated syntax, you can take advantage of the new, more straightforward way for referencing secrets from HashiCorp Vault thanks to the new Remote parameters concept.

You can extend TeamCity’s remote parameters in any way you like. With the new remote parameters in TeamCity, we’re introducing an easier approach to setting up connections to external vaults and other applications. With this, we’ve built the foundation that will make it easier for us to develop new plugins and for you to develop your own.

Dec 13, 2023
Dec 19, 2023
bottom of page