Azure DevOps Server

Formerly Team Foundation Server

Integration with Microsoft products, like SharePoint, IIS, Visual Studio

Users are able to access via desktop client, web browser and through Visual Studio

Code version control

Bad UX and UI in the web interface

Merging code is a very hard task

Development in branches is also hard to achieve

Not so easy to upgrade server version

The consolidation of issues is extremely useful for us. Having one place where all bugs are entered has helped our business process immensely.

Being able to query data regarding user stories, bugs and code is extremely helpful. As well, using the visual tools built into the system can help with messaging regarding the status of a project.

Being able to monitor code deployments is extremely helpful. Since we are managing multiple environments, this tool makes it easy to see what is happening where.

Searching through code can be somewhat cumbersome. It would be nice if there was a way to do general searches in certain areas of the system.

Without proper training, the system can be confusing to navigate. This issue can be prevented with good training but it is something to be aware of.

Navigation can be clunky at times depending on where you are in the system. For power users, this is not a huge deal but it is a tad bit annoying.

The environment is easy to use.

It is very easy to track progress of various work items.

Project management is made really easy.

There is no ability to work offline.

There is a learning curve involved which is little hard to get when you are using the tool for the first time

The UI can be little more organized.

Version Control

Track Bugs, Change Requests, Tasks

Compare versions of SSIS can be improved

Merging of the SSIS Code can also be improved

I like the Team Foundation Source Control Management much more compared to other Systems like GIT, because:

- Perfect Integration into Visual Studio

- Easy and direct checkout/check-in

- Perfect branching and merging

- Workflow Support with autmated Reminders

The Build System is just great. Since Version 2017 its very easy to integrate self made tools into the build process.

Easy Managament of Users and User Rights.

Team Foundation Server could be improved in the Task and Backlog Managment for smaller Teams. E.G.: It's hard to quickly write down Tasks during a meeting because you have to fill in lots of Fields per WorkItem. It is hard to push the Items around.

Security

Reliability

Scalability

TFS templates are not as flexible as the business requires

No data loss

Multiple deployments

Deployment without problems of versions

You must avoid getting stuck with check-in

Developers must avoid overwriting

The developers must be at minimum coordinated among themselves during the developments

Continuous integration when the team is using azure is really easy.

It's fairly intuitive to use.

Azure or IIS deployment is very easy.

The project management/scrum piece is hard to learn.

The Wikipedia functionality it provides isn't very useful for lack of features.

It takes a REALLY long time to check in a large number of newly added files.

If your file paths get too long, TFS gives you errors.

Traceability between MS Suite

Clear what's a Bug, User Story, Feature, Epic

Linking test cases

Bad use of real estate is it's No. 1 failing, why all the white space?

Too much functionality makes it difficult for new users to jump onboard - it's daunting at first

Configuring dashboards is easy, but not necessarily what you want to show to upper management - needs some tweaking

Work Item tracking - The ability to define the flow of your work items to match your development/test process is really valuable

Version Control - The ability to easily track changes between every checked in version of source code can be a life saver

Project Management - The project management dashboards showing things like burndown enables us to easily track whether we are on target for a release

Integration between our help desk system and TFS was possible but not as easy as I would expect considering both are Microsoft products

Advanced reporting for dashboards could be made easier

Source code management - Team Foundation Server handles our source code and makes examining check-ins and changes nice and easy.

Project Management - Keeping the thousands of feature requests and bug submissions under control and in the right place is simple enough in TFS.

Administration - As with most Microsoft products, administration is not a difficult affair. Familiar interfaces and tight integration with other Microsoft products make most tasks intuitive.

Web interface - While the web interface is certainly very feature rich, there's just no substitute for a good desktop interface sometimes. The test side has Microsoft Test Manager as a desktop application counterpart, but almost everything else is done via the website. Some project management tasks could be simpler in a desktop environment.

TFS has an excellent interactive UI for all users to make source control easy to use.

TFS has the backing of a major company, Microsoft. Updates and the way it is used gets regular updates.

TFS integrates into Visual Studio.

TFS has many tools for many different areas in the development life cycle.

There is no real ability to work offline. You need to be actively connected to it in order to see history.

Having many hands in the same project/file can cause conflicts that can be hard to resolve.

having a "master" branch is difficult in TFS, it can be done but it is slow and cumbersome and not an intuitive process.

Automatic generation of burn down chart

Easy to link user stories and tasks across

Easy to move tasks across user stories

Easy to move user stories across sprints

There are issues encountered when uploading more than one attachment to a task. One needs to refresh first then save.

The Admin function where you add iterations isn’t very user-friendly.

Project management

Scrum

Integration with visual studio

Not a user friendly implementation of Git

TFS version control is not widely used in favor of Git

Work Item management.

Build automation - enables Continuous Integration out of the box, cross-platform, easy to use.

Code repositories - Hosts Git and TFVC repositories, provides excellent pull request experience for Git users.

RESTful API - Provides the ability to script/automate just about anything.

Visual Studio Team Services just about solves all of the criticisms I had of TFS.

Release Management is overly complicated and changes constantly, hard to keep up. I use Octopus Deploy as an alternative.

Tractability, Code to defects, Test cases to Requirements

Metrics - Reworks on development, test cases to change, Defect by root cause

Single source for all to pull data, business and IT

Simplify automation testing, too much repetitive code with recording

Easier access to Code reviews - our development team struggles with this

Shelving and un-shelving details - development struggles in this area

Field customization is a feature TFS has that I particularly like. We have a very specialized customization of TFS running so that I can query for specific iteration/release paths that are relevant to our metrics. We also utilize a unique workflow structure for bugs and user stories as the process from creation to close is unique within our company.

TFS does their web view really well, especially with newer versions of the product. Often times, I feel that very little is lacking when I am logged into the web view of TFS. I am able to bulk edit items in the newer version of TFS, and at my old job we even set up the ability for QA to push checked in code to stage environments through TFS.

Finally, I feel TFS does a very good job of keeping historical track of actions performed to tickets. If someone has edited a ticket in any way, I can review and identify who made the change and when. This helps give me context when a developer contacts me to ask me a question related to the wording of a ticket. This also helps hold people accountable if tickets are written incorrectly or incompletely and prevents people from passing blame to others.

The older versions of TFS are more lacking in the web version-- if you aren't updated to 2015 or above I believe, a lot of the web features are not available (like bulk update). You really have to keep up to date with TFS for the best features, and it's no simple task to migrate your entire instance of TFS from an older version to a newer version.

VSTS is supposed to be a virtual version of TFS that we've been looking into, but it severely limits customization options for ticket templates and workflows. It would be nice for VSTS to eventually carry that customization over so we could feel more comfortable switching to "the cloud" so to speak.

Queries are a very powerful tool, but normal business users struggle to understand how they can best utilize this tool to analyze tickets. Because of the permissions structure in all companies I have been a part of, I've never been able to save my custom queries to a public folder in TFS for business/project users. Instead, I have to take time to train these users and give them guidance on how to best create queries for their needs. This is admittedly a business process issue, but it could potentially also be resolved with some good training/guidance around queries provided by TFS themselves.

Team Foundation Server makes it easy to develop and debug code. While coding, if a variable is missing or comma or something is misspelled team foundation server uses Microsoft visual studio to develop code which helps find where the line of code is with the issue.

Test Manager makes it easy to link test cases with pieces of code for developers or test cases for front to end testing for QC analysts. Linking test cases to pieces of code and requirements is super simple.

Test Manager makes test automation easy to re-run test cases in the event the same steps will be taken multiple time for a particular test suite. I had one test suite with over 100 test cases and the first 10 test steps were the same for each test case. I set up automation testing using test manager and was able to skip the consistent clicking on the first 10 steps for the 100 test cases.

I think if old coding languages were easier to migrate and keep in TFS as a archive and easy to access then that would be a huge improvement.

Easier to create dashboards within TFS of the approvals for projects.

Import work items in Excel and change in bulk. Then publish to TFS. This is the most efficient feature of TFS.

Change Set description editing even after check-in is committed. Link work items with each other.

Branching with more options from TFS command.

Use different version from different branch and build on top that - This feature is missing. This feature we can see in Clear Case.

We cannot query well on History field. We should be able to create query where History contents are specifically given by words or phrase.

Branch & Label Diagram is also missing or may be I am not aware of how to do that.

TFS code management is superior to other products we've used. Merges, check-ins, rollbacks, and version management techniques are much less error prone.

TFS tasking and traceability to code for tasks are some of its best features. Individual and team tasking can be applied to any methodology template a manager would want to use to manage a team.

TFS usability and unit testing suite is very flexible. Tests can be built all the way from the bottom unit test up to a functional level (understandable by functional people) and automatically executed for regression analysis.

Detailed custom changes to development methodology templates could be less difficult. The version we've worked with required development knowledge to make custom changes which should be doable by higher level management.

When using multiple TFS in a hierarchical/multi-enclave structure synchronization of code and functionality pushed from one to another can be a bit buggy at times.

Team Foundation Server's built in Agile work flow template provides us an excellent out-of-the-box framework to manage our software projects.

Team Foundation Server's source code repository is easy to use and has all of the expected features that a large software development organization needs.

The Web Portal has a responsive and very easy user interface that allows the Scrum Master to make updates to User Stories, Tasks, and Bugs while members are reporting their status each day.

Team Foundation Server integrates with an SQA test module called Microsoft Test Manager (MTM). The integration between MTM and Team Foundation Server is not always straight forward. Some things can be done with Test Cases in the Team Foundation Server UI while others can only be done in MTM UI and vice versa.

The Team Foundation Server web portal is good for performing some actions, while the native client app is better for other actions. It is not as efficient or effective to have to know and work with the two different approaches.

Allows a great deal of history detail on every issue found or new feature added. It keeps a detailed history of any code changes by developers so you can always see who changed what portion or code.

You can adjust users permissions down to a group of users (i.e. testers vs. developers vs. managers) and can get very technical with permissions for each group. The permissions can also be set based on certain portions of the code base not just on the entire thing.

The information that is tracked is great. When you find an issue and you log it in Team Foundation Server you have many options for fields to utilize and edit to make sure you get the correct team of developers to look at it. You can also have different requirements for each issue or when checking in code such as changes made, priority level, area and iteration (these are used for internal development purposes usually).

Simplify the permissions interface and navigation. Permissions are great but sometimes finding the correct screen is difficult.

Make the interaction between different versions easier. Sometimes you can run into issues when trying to use an older Team Foundation Server server with a new Team Foundation Server Build server. This occurs when you don't have the resources to upgrade all servers at once.