What is our primary use case?
We use TFS for all of our source code. We develop a software suite with about eight different applications that work together, and then we also do firmware development. We use it for our firmware development source code repository.
It is deployed on a private server. We've gone all the way from version 2012 up to 2017, and we will be doing the 2019 upgrade very soon.
How has it helped my organization?
An example would be that now we have scheduled releases. We have scheduled builds that happen every Thursday that get rolled out to our development testers. In the past, before TFS, the developers themselves used to initiate that, and it was done randomly. So, being on a schedule is much better.
It basically enforces our rules. Because everything is more controlled, source code cannot be checked in unless it builds correctly. It basically forces the developers to adapt to the agile methodology that we use, which is small chunks of work at a time.
What is most valuable?
The most valuable features are related to source code management. Using TFS for source code management and being able to branch and have multiple developers work on the same projects is valuable. We can also branch and merge code back together.
Another valuable feature is our continuous integration because we do continuous builds. So, continuous building with the build server is also very important.
What needs improvement?
They have room for improvement in merging the source code changes for multiple developers across files. It is very good at highlighting the changes that the source code automatically does not know how to handle, but it's not very good at reporting the ones that it did automatically. There are times when we have source code that gets merged, and we lose the changes that we expected to happen. It can get a little confusing at times. They can just do a little bit better on the merging of changes for multiple developers.
When you restructure your source code, the historical information doesn't directly come across. It doesn't link when you move those source folders around. I would like to see that ability. The whole source code control system should show you the history of all the changes you made to a bunch of files. If we take a folder with a bunch of files and move it from one place to another, the history is gone. It just doesn't bring over the history of everything that was moved. That has prevented us from restructuring some of our source code to suit the larger number of developers that we have. I haven't called Microsoft to see if there is help that they can give me on this because on the web and on their sites, I can clearly see that that is just the way it is, and we're not doing something wrong. So, that is something for which I would really like to have the ability.
I can't recall the versions, but when I upgraded from one version to another, it didn't retain history as well because they made some fundamental changes. It might have been from 2012 to 2015. I upgraded and moved it to a new server, and it lost the historical information. We needed the old stuff running so that we could access the historical data. So, the upgrade path wasn't that easy. I don't know if that's the case anymore. When we go to 2019, we'll be finding that out.
Learn what your peers think about TFS. Get advice and tips from experienced pros sharing their opinions. Updated: May 2023.
708,243 professionals have used our research since 2012.
For how long have I used the solution?
We've been using TFS for 10 years.
What do I think about the stability of the solution?
It has been extremely stable. We don't have any issues with it. It works. Performance is good. All the features that we turned on are working exactly as we expected.
What do I think about the scalability of the solution?
So far, so good. We've had one external developer consultant that had to come in and access it as well, and that went well. I don't have any gauge about how it would be for a team of 50 developers. The hardware we're running on it right now probably wouldn't be enough, but I don't feel that it wouldn't be able to scale to a larger number of developers. From a security model perspective and from a functionality perspective, it seems to have all the features to be scalable. I just don't know about the performance. That's all.
Currently, there are five of us who work with this solution. We have one project manager and four developers. We have one firmware developer who does not work in the Visual Studio environment. This firmware developer works in a microchip MPLAB X environment. All other developers work in the Visual Studio development world. So, it's more integrated, but both roles work. The same people also take care of its maintenance.
From a source code management perspective, it is being used very extensively. From a build server perspective, it is used extensively. We don't do release management with it, and we don't have integrated automated testing turned on in it as well. Those are two fairly large areas of functionality that we don't use currently. We may in the future, but we're not using them right now. We're using about 60% of the functionality.
How are customer service and support?
From a technical support perspective, we've used the Microsoft website to get answers to our questions. It has been very good that way. I would rate it a five out of five in that aspect.
We haven't had to call a person or open up a case. We've been able to do our own self-support through the knowledge base that they supply. There are a lot of users of this product. So, a lot of the typical problems that people experience are out there, and it's easy to find them.
How would you rate customer service and support?
Which solution did I use previously and why did I switch?
In different roles that I've had with different companies, I've used CVS, which is a different source code system. It's on the Linux system. It's not on Microsoft Windows. I've also used TortoiseSVN. I find TFS much easier because it's fully integrated into our solution.
In the previous world, I wasn't the decision-maker about which one to use. I came into projects that already had those in place, and they were not developing on the Microsoft platform. I understand why they didn't use the Microsoft platform in that case. In our world, we're developing software that runs mostly on the Microsoft platform, so it made sense to do that. Originally, when I used other packages, I was working as a consultant. I was working at different places, and I was using whatever the decision-makers used at those places as their source code control systems. When we started this company and I was the decision-maker, I used the Microsoft TFS platform.
How was the initial setup?
It's relatively straightforward for a developer. On the initial setup, I'd probably rate it a four out of five.
It took us about three days to get everything set up correctly, but we complicated our environment as time went on. We started off with one developer, then up to two, then to three, and then to four. So, as we increased our number of developers on the team, we changed the complexity of how it was deployed. It wasn't all done in one shot. It was done over a period of time. If we had to set it up from scratch today, it would probably take us about three or four days to map it out and do it correctly.
The more developers you have, the more complicated the setup has to be because you need to set up permissions and you need to set up roles and responsibilities. If it was just one team doing the same thing, it would be no different for one developer or five developers, but because we have different areas of expertise that we work in, we were trying to protect certain code bases from one developer from another. So, it just becomes more complicated. It's really just a security permissions thing that makes it complicated.
What about the implementation team?
We did it all ourselves. We haven't outsourced. We have a company that we deal with that maintains our servers for us, but they don't have any TFS experience. We coordinated these changes through them, but we dictated the changes. So, they didn't provide us with any expertise.
What was our ROI?
We develop software for the oil and gas world. Our software runs right on drilling rigs and downhole and also on tools that we put downhole. When there are problems, we need to fix things quickly. It is critical. We're tens of thousands of dollars an hour at a rig, so we do need to make a quick fix. We now have release management and the ability to do small, hotfixes, and things like that to help customers. Definitely, time is money. It allows us to go back in time very easily to a known configuration in our worlds. We can go back with our source and pull out the code and compare and diagnose any problems that are occurring. It helps to rule out and diagnose problems quickly and way more efficiently in real-time. We remove the uncertainties of what software is and where and what has changed. It really helps us there. It helps us respond to our customers' needs in a much faster fashion and saves our customers' money in a way.
What's my experience with pricing, setup cost, and licensing?
I believe we pay on a yearly basis. I don't know the current costs of them. We outsource all that to a third party. Each of the developers gets a Microsoft Visual Studio Azure DevOps license, which gives them access to the TFS server as well. We probably pay on average about 1,800 Canadian Dollars a year for every developer, but that covers a lot more than just TFS.
The cost isn't prohibitive. We use a lot of different software in our company. We use a lot of engineering software. If I compare the cost of our developer team software to some of our other solutions, such as our CAD package SolidWorks or our PCB design software Altium, we pay orders of magnitude less for TFS than we do for those other packages. Microsoft's licensing terms are also much better. They're good. I would rate them a four out of five in terms of pricing.
The only additional cost that you have is that you need to run it on a server, and you need a Windows Server software license. If you didn't have that to start with, you'd have to purchase it, but we already had that for other services within the company, such as file services, print services, etc. Other than that, there are not really any costs.
Which other solutions did I evaluate?
I'm always evaluating different things. The original Microsoft product, which was Visual SourceSafe, was something with which we had done some work in the past. TFS was the next release of that. I thought Visual SourceSafe had some shortcomings. I evaluated the difference between TFS and Visual SourceSafe and decided it was the right way to go.
I've used Git as well, which is now becoming fully integrated with TFS. So, I evaluated that. I like a lot of the features of Git because of the user community that uses it. The open-source community highly integrates with it. TFS is now integrated with that as well, so I've had no reason to switch entirely off the TFS system.
Git is really a source code control system. The pro is that there is a very large component of open-source software that is supplied through the Git interface. A lot of developers of open-source applications expose access to their source code through Git, whereas Microsoft TFS is not like that. They don't do that. Microsoft TFS is more for internal. Microsoft TFS now supports Git, and it will use Git even as its underlying source code control system. So, TFS does integrate with Git directly now, and all the benefits of Git are now in TFS.
What other advice do I have?
The only advice I would give is to design the security model and the developer model assuming that you have a larger team of developers than what you have when you start. You should set it up originally for multiple users to be working on the projects rather than having to change your methodology partway through.
We made some decisions on how we structured our source code and how we structured our team projects, and I would not have done that if I had known that the developers would be working on it in the fashion that we do now. Your configuration for ten developers would work with one developer too, but the configuration for one developer doesn't always work for ten developers. So, set it up for ten assuming that you're going to be doing that.
I would rate it a seven out of ten because of the issues with the upgrade path, restructuring folders, and things like that. If you don't configure it right to start with, it's a little bit difficult to change. That's the only reason that I'm not giving it a nine. If I have to make the same decision again, I absolutely would buy it again. It does what it was advertised to do, and it's not causing us any harm. It's doing its job, and it does it well. There are just a few things around the upgrade and around the restructuring of source code that could be improved. That's all.
Which deployment model are you using for this solution?
Disclosure: I am a real user, and this review is based on my own experience and opinions.