Part 1: Introduction

1. What is TeamCity?
2. What is continuous integration?
3. TeamCity capabilities
   • Build and deploy automation
   • Version control system integration
   • Static analysis and code coverage
   • Reporting
4. Supported platforms and environments
5. Licensing and cost

Part 2: Creating a project

1. Logging in to TeamCity
2. Create a TeamCity project with a repository URL
   • TeamCity analyzes build file
   • Select desired build step
3. Add project to overview page
4. Run build
   • View test results
   • View build log
5. View build configuration options
   • Build number counter 
   • Build number format and variables
   • Build triggers— a brief overview of what they are
   • Artifact paths
6. Pre-test a change
   • IDE integration
   • Remote run a change
   • Show “personal build” on TC
7. Commit breaking code to version control system
   • Observe build being triggered and failing
   • Create investigation and assign to self
8. Fix build

Part 3: Projects and builds

1. Projects
   • Settings
   • The project hierarchy
2. Build configuration types
   • Regular
   • Deployment
   • Composite
3. Build configuration settings
   • Version Control System configuration
     • GitHub, Bitbucket, Team Foundation support
     • Feature branches
     • Multiple repositories
   • Build steps—overview of bundled runners
     • .NET Cli          
     • Gradle
     • Ant
     • Command line
     • Maven
     • MsBuild
     • Others
     • Advanced configuration—run in a container
   • Build Triggers
     • What is a build trigger?
     • Repository changes
     • Schedules
     • Dependency changes (Maven, NuGet, etc.)
     • Retry or build finish triggers
   • Failure conditions
     • Maximum build duration
     • Error message in build log
     • Metric changes
       • Artifact size
       • Class count
       • Number of failed tests
       • Code coverage minimums
   • Build dependencies
     • Snapshot dependencies
     • Artifact dependencies
   • Build Features
     • Docker support
     • NuGet credentials
     • Free disk space
   • Build Parameters
     • Environment variables
     • System properties
     • Configuration parameters
   • Logs
     • Change logs
     • Build logs

Part 4: Manually Add Project

1. Create new project
2. Add name
3. Add repository URL
4. Configure build (Gradle—see notes)
   • Select build type
   • Add build step for clean
   • Add step for build
   • Build file name
   • Gradle home
5. Review advanced options
   • Debug options
   • Logging options
   • JDK version options
6. Run build
7. View results

Part 5: Tests

1. Framework support
   • Java/.NET/Ruby
   • Plugins
   • Adding support for custom tests
2. Test results
   • Deeper examination of changes and ties to VCS
   • Deeper examination of build logs
3. “Flaky” tests
4. Investigations
5. Exercise: more complex tests
   • Add a more complex project with tests
   • Make tests fail
   • View logs and changes
   • Start investigation
   • Clear build problem

Part 6: Code inspection configuration

1. Bundled code inspection tools
   • IntelliJ Java code inspections
   • Resharper .NET Code Analysis
2. Viewing reports
3. Exercise:
   • Add analysis build step with IntelliJ inspector
   • Run build
   • View report

Part 7: Deployment builds

1. Deploy Maven packages
2. Deploy NuGet packages
3. Deploy Docker images
4. Exercise: deploy Docker image
   • Verify agent is available with Docker support
   • Add project with a Dockerfile
   • Add/view Docker build step
   • Run build
   • Pull docker image from Docker hub and run

Part 8: Customization

1. VCS accounts
2. Notifications
   • Rules
   • Mechanisms
3. IDE integrations
   • IntelliJ
   • Visual Studio
   • Eclipse

Part 9: TeamCity administration

1. User profile customization
2. Installation and configuration (See notes)
   • Install on Windows
   • Install on Linux/Mac
   • Install on Docker
   • Install in cloud
   • Creating users
3. Configuration
   • Notifications
   • Plugins
   • Database support
4. Administration
   • Authentication