TFS Reviews

My primary use case for TFS is to track source code changes, including branching, merging, and comparing changes. I also use it to check in and out code, track changes, and maintain a history of modifications. 

The solution has been valuable in managing source control and tracking code changes, improving code management and development efficiency. However, it has not significantly impacted project delivery timelines or cost efficiency.

The product's most valuable feature is the ability to view and track the history of changes. It allows me to see previous modifications and helps develop similar features by referencing past work.

The product access management features and connectivity need improvement. Rights management is also complex and could be simplified. 

Additional automation features would be beneficial. 

I have been using TFS since the early 2000s.

The solution is generally stable, though connectivity issues have occurred, often related to VPN usage.

I have used a similar solution sparingly.

The initial setup was straightforward: creating a new project, importing code, and setting up branches.

The setup was done in-house.

TFS is effective for code management and tracking but could benefit from improved automation and simplified user management.

Overall, I rate it a seven out of ten. 

I use it  for managing. To manage the project in Git and manage branches in projects. 

Merging branches is definitely one of the more challenging aspects for people new to TFS.

I have been using it for three years. 

Stability is okay. I would rate the stability an eight out of ten. 

I would rate the scalability a six out of ten. Sometimes, a lot of branches get mixed together, making it difficult to use. I remember struggling with these branch management issues some time ago and even wrote about them. It is so hard to review problems in TFS.

There are around 200 end users using this solution in our organization. 

I found Git to be a better overall experience. Merging branches in TFS, especially merging to the master branch, could be quite difficult. Git seemed to handle it more smoothly. However, after two years, the company decided to switch to Git.

For experienced users, it might be manageable, but for non-technical users like nurses, branching and merging in Git proved difficult. They often had to ask for help from team members because they found it challenging.

Overall, I would rate the solution an eight out of ten. 

At my previous company, I was using TFS for managing projects and code.

The most valuable feature is the backlog.

The reporting has improved over time, with the addition of Power BI reports.

There are a lot of places that Microsoft can improve this product, as well as their support.

The program and portfolio planning facility can be improved. As it is now, you can't do portfolio program planning functionality across multiple project Areas (vs. Team areas within a project area) because you cannot link items across projects. Reporting can be done using Power BI, but real time connections are difficult.  You can use connectors and external integrations but you cannot do it with the tool. It needs to be better. 

It is difficult to customize.

I had been using Team Foundation Server for between four and five years.

This is absolutely a stable platform. It is highly available and follows on the environment.

It is possible to scale, albeit tricky. There are between 2,000 and 3,000 users.

Technical support is a challenge. It is a pain to get anything from Microsoft done. For example, working on patches and queries is slow. There was a lot of functionality that we wanted to embed that we had trouble with.

They changed the entire application lifecycle management suite, so it was a challenge to understand and navigate through how things would be done.

It is not a buggy product, but for new functionality, it is really a challenge. Especially in cloud-based deployments, it is even more challenging.

I was using TFS at my previous company and my current organization uses JIRA. I would say that TFS is the more scalable of the two. With JIRA, you really need connectors and things like that. You have to have external addons to make it more scalable.

In terms of usability, JIRA might provide a better user experience but from an organizational and stability point of view, TFS wins hands-down.

Price-wise, TFS is better than JIRA.

Out of the box, the initial setup is easy. However, it is difficult to customize, especially if it is on a cloud. 

TFS is more competitively priced than some other solutions.

My advice to anybody who is implementing this solution is to use as much as possible, out of the box. Customizing it is difficult. It may not necessarily fit everything perfectly and it can be tricky to scale, but not impossible. There are definitely challenges scaling it. That said, the tool from Microsoft does allow you to do things very differently but try to do it in a standard way first.

I would rate this solution an eight out of ten.

I use this solution in my organization as a product owner who manages backlogs in DevOps. I manage the backlogs items and use it to collaborate with my developers.

There are less than 100 people using this solution in my company.

The solution is deployed on-cloud.

It's user friendly. We haven't had any issues so far. It's flexible. If we need something, we can always contact the owner in our headquarters to make a configuration.

I only use 1% of the functionality, so I am not familiar enough to know what needs to be improved.

I have been using this solution for a couple of years.

It's stable.

It's scalable.

I would rate this solution five out of ten.

We are using the core repository for the complete development life cycle. 

The solution helps with pretty much all aspects of the development cycle. This includes using it for QA, testing, development, and the release. It's useful for every aspect of the development cycle.

The initial setup is fairly easy.

The continuous integration and continuous delivery should begin with DSS. It doesn't right now. That needs to be changed.

The phased release process could be better. Instead of shelving the call and unshelving the call, it should be done in phases. In an updated version, this should be something they adjust. It needs a more effective release process. 

There should be management of the project built-in.

I've been using the solution for more than five years.

The stability of the solution is good. There aren't bugs or glitches. It doesn't crash or freeze on us. It works. It's good. We haven't had any issues when it comes to stability.

The scalability of the solution is very good. If a company needs to expand outwards and grow they should be able to fairly easily. We've had not trouble with that aspect of the solution.

We don't have technical support for this solution, therefore I can't speak to how knowledgeable or responsive they are.

We are still using TFS, however, we're considering switching to Microsoft Azure DevOps.

The initial setup is not complex. It is very much straightforward. It shouldn't give an organization too many problems.

I didn't deploy this solution, so I can't speak to how long it actually took to do so.

We had the help of consultants from Microsoft. The implementation was five years ago, so I can't recall too many details, however, I believe we were pleased with their work.

Overall the solution is good. It's scalable and stable and has been working well for us. Of course, the phased release could be smoother, and it's something they need to improve upon.

I'd recommend this solution, even though we do plan to move to Microsoft Azure DevOps.

I'd rate the solution eight out of ten.

We use Microsoft Team Foundation Server as part of our development framework. Most of our development technology is from Microsoft and our primary language is C#, although we do have a number of Java programmers as well.

We primarily use TFS for managing our resources and scheduling. We can also use it to check to see whether tasks have been completed by the team, or not.

The most valuable features are the dashboard and task-selection capability.

The option to save favorites is helpful for managing pages.

I would like to see TFS integrated with a project management solution, such as Microsoft EPM. Right now, it is isolated from EPM but if we could somehow connect it, then that would help a lot. As it is now, the results are not easy to report to project managers, which makes it difficult to estimate both cost and the time to completion.

The interface can be improved and made more user-friendly.

We have been using TFS for about five years.

This solution is stable and we have not had any crashes to this point. We use it on a daily basis. All of our new projects start on TFS.

This is a scalable solution. Our company has 1,300 employees, although there are only between 50 and 100 who use TFS.

Because we are in Iran and there are sanctions, we do not have a Microsoft agent and we have never been in contact with them. We instead rely on various forums and searching for solutions using Google. Using Google is the fastest way to get results.

We did not use a similar solution prior to implementing TFS. However, we did use Microsoft Project for scheduling. It was not specifically for the purpose of software development, but we used it for putting together the steps of a project. For example, first, the UI would be developed, and then the backend. These steps were listed in the project management software.

I did not personally perform the installation, although my colleagues had no problem and I got the impression that it was easy.

Our in-house technical people installed and deployed this solution. There were two of them involved in the process where one took care of the servers, VMs, and infrastructure, whereas the second person installed the solution and gave us the link to use it.

We have lots of servers and virtual machines, with two people in charge of maintaining our infrastructure. One person is generally in charge of installing and maintaining software as was with TFS, and this person is also responsible for the maintenance.

There is a gap between project management, agile methodology, and TFS resource management. If they can fill this gap then it would be a great improvement for us and many other companies.

My advice for anybody who is implementing this solution is to keep in mind that using the tool, alone, will not change the way they develop their software. First, they should become familiar with agile methodology, and then they will be able to properly use TFS.

I would rate this solution an eight out of ten.

• Source code management
• Branch/merge tools
• Build capabilities
• Work item tracking
• Scrum board management

We've reduced production deployment rollbacks 100%.

Build definition management - there needs to be change control for build definitions

I've used it for 10 years.

It's a long upgrade process, but works fine.

No issues encountered.

No issues encountered.

8/10

8/10

No previous solution was used.

It was straightforward. It's mostly wizard-driven, with plenty of built-in validation for most steps.

Virtually immeasurable. The low cost of the product is nothing compared to the productivity improvements it brings.

Size accordingly. Not every shop needs every feature.

Size accordingly. Not every shop needs every feature.

Recognize the fact that TFS isn't just a source code management tool. It's an application lifecycle management tool that covers all facets of software project management as well as development, deployment, and production support.

We use this solution for corporate internal SW development of small business applications manly in .NET.

I am the administrator and configurator of TFS Servers and other DevOps related tools (Jenkins, Ansible, Nexus, SonarQube). I create the projects and configure the full life-cycle, with a deployment model mainly on-premises for now.

Better team collaboration and Issue tracking.

I like the build management features, the integration with Jenkins and many other tools.

The team rooms for team collaboration, and issuing the backtracking are very valuable features.

One of the areas that could be improved is to have an effective full life-cycle management.

For example, when the developing team has an issue with a bug, they can relate and tag sources and builds to that bug, but after that, it's not easy to track if those builds where in fact deployed.

In the next release, I would l like to see a modern solution with a full integration of the real life-cycle.

This solution is stable.

This solution has some scalability.

We have contacted technical support (local Microsoft) a couple of times I would rate them a four out of five or a nine out of ten. They are good and I am satisfied with the help that I have received from them.

Previously we used manily another solution (Serena Dimensions CM). But specially Java developers hated it, so we start to migrate to GIT and Jenkins for them, while .NET developers prefer to use TFS.

The initial setup was straightforward. We did have some issues, speacilly in the use of the databases but due to our customer internal policies, who were old fashioned and gave us some problems, but we can't blame the software for that.

TFS licencing can be confusing, we have to read it well and have a good user management strategy and control.

We evaluated modern versions of Microfocus and SVN, we still have Dimensions CM but will be discontinuing it.