Request a Quote
Team Foundation Server 2013 Advanced Topics
Course Duration 2 days
Training Overview

This two-day, instructor-led course dives deep into Team Foundation Server (TFS). Students will explore areas of process templates, template customization, advanced version control, parallel development, Team Foundation Build, extending Team Foundation Server, and a variety of preferred practices. This course provides students with the knowledge and skills to effectively understand, customize, and leverage these features and capabilities.


This course is intended for students with a working-knowledge of Team Foundation Server or who have attended comparable training classes.

Before attending this course, a student should have experience using Team Foundation Server. Additionally, students should:
  • Have familiarity with their team’s software development process
  • Have experience developing and supporting multiple versions of a software product
  • Have experience working with multiple developers on a software development team
  • Have experience with the types of conflicts that can arise from a multi-developer project
  • Be able to read and understand C# .NET code (all source code will be provided)
  • Understand the Microsoft Windows operating system and security basics
At Course Completion
At course completion, attendees will have had exposure to:
  • Process template architecture
  • Modifying a process template
  • Creating and altering work item types
  • Customizing TWA agile planning tools
  • Using the process editor power tool
  • Creating and using global lists
  • Parallel development concepts and challenges
  • Parallel development support in TFS
  • Branching and merging patterns and strategies
  • Selecting an appropriate branching strategy
  • Version control workspace types and usage
  • Setting up and managing workspaces
  • Using branch and merge commands
  • Forward integration and reverse integration
  • Using shelve and unshelve commands
  • Detecting and resolving conflicts
  • Securing folders and files in version control
  • Using the TF and TFPT command line utilities
  • Installing and using the MSSCCI provider
  • Using alternate compare and merge tools
  • Team Foundation Build architecture
  • Setting up a build controller and agent
  • Running tests during a build
  • Queuing a build in different ways
  • Implementing Continuous Integration
  • Supporting code coverage and code analysis
  • Using gated check-in builds and private builds
  • Build security and build permissions
  • Team Foundation Build community projects
  • Customizing a build process template
  • Selecting and using a build workflow activity
  • Client and server object models
  • Extending work item tracking
  • Extending version control
  • Creating a custom check-in policy
  • Extending Team Foundation Build
  • Using a custom Team Build workflow activity
  • Team Foundation Services
  • Team Foundation Server eventing service
  • People, process, and tools: preferred practices
Course Outline

This module discusses process templates and the tools and techniques used to tailor them for a team’s specific needs.

  • Customizing vs. extending
  • Process template architecture
  • Modifying a process template
  • Customizing work item types
  • Using global lists
  • Customizing process guidance
  • Customizing Agile planning tools
  • Explore an existing process template
  • Customize a process template
  • Customize a work item type
  • Modify Agile planning tools behavior
  • Create and use a global list
  • Use work item templates (optional)

This module offers an advanced discussion of Team Foundation Version Control, relating to multiple users working on code in the same team project.

  • Introduction to parallel development
  • Workspace and locking models
  • Branch, merge, shelve and unshelve
  • Branching patterns
  • Conflict detection and resolution
  • Securing folders and files
  • The TF.exe command line utility
  • TFS Power Tools
  • Shelve and unshelve changes
  • Branch code and manage branches
  • Understand and resolve conflicts
  • Merge changes between branches
  • Secure artifacts under version control
  • Use an alternate merge tool (optional)
  • Use the MSSCCI provider (optional)

This module is a deep dive into Team Foundation Build, including a more technical look into the build process and how to customize it.

  • Team Foundation Build architecture
  • Automating and securing Team Build
  • Implementing Continuous
  • Integration
  • Gated check-ins and private builds
  • Tagging build agents
  • Team Build community projects
  • Customizing build process templates
  • Team Foundation Build FAQ
  • Configure Team Foundation Build
  • Override a build’s default behavior
  • Configure additional build agents
  • Configure a gated check-in build
  • Configure a private build
  • Customize the build process template
  • Install additional build activities

This module explores the APIs that are available to developers wanting to extend TFS.

  • Extending Team Foundation Server
  • Relevant object models
  • Extending work item tracking
  • Extending version control
  • Extending Team Build
  • Team Foundation Services
  • Extend work item tracking extensibility by creating a custom work item utility
  • Explore version control extensibility by creating a custom check-in policy
  • Explore TFS events by creating and registering a custom WCF application

This module reviews many of the practices that TFS teams prefer to use.

  • Team projects, areas, iterations, work Item tracking, and licensing
  • Version control, branching, shared code, dependencies, and builds
  • Collaboration, productivity, code reviews, feedback, and getting done!
  • This module contains no hands-on activities
Course Designer

This course was designed by Richard Hundhausen, a Visual Studio ALM MVP, Microsoft Regional Director, and an experienced software developer and trainer. For more information about his company, or to see other courses that they offer, visit