What is our primary use case?
We have Fuse installed on our on-premises servers, and we use it as an enterprise service bus for connecting different applications. For the time being, all of these applications are installed on-premises.
We also use cloud-based applications, but none of them is currently interacting with Fuse.
We try to implement third-party applications, if possible, out of the box and, if not, with minimum customization. That leaves something which is very important outside. The applications in many cases have to talk between each other and this is why we need integrations.
So, we chose Fuse to act as a membrane or glue for all of our applications to be able to interact. For that particular purpose, we hire third-party development companies that create the integrations for us, but we chose Fuse as this membrane that glues everything together because that was, when we first evaluated it, the best approach that we could select at that point in time.
How has it helped my organization?
The comprehensiveness of Fuse's API management is quite good, and this is important to us. From a usability standpoint, particularly for the developers that have to interact with the API, it's fairly straightforward. We don't have in-house developers. We always make use of third-party companies to develop integrations for us. We don't interact directly with the APIs. Rather, it's third-party development companies that we hire to create integrations for us.
Having said that, most of the companies that do such integration development for us, maybe half of them have experience with Fuse, and the other half who don't have experience can handle the APIs pretty well once they are exposed to them and someone explains to them how they work. These third-party companies have been working for us for maybe two or three years and have no problem at all with the APIs.
With respect to reducing our developer's dependency for integration and custom code, our situation is mixed. We rely on developers to create integrations so it has not changed in that regard. However, if we compare it to a non-enterprise service bus integration scheme then there is less dependency on developers.
At the end of the day, we rely on external developers for creating integrations and maintaining them because, of course, maintenance occurs. Businesses have changing requirements so we have to adapt those integrations. In the comparison with a non-enterprise bus scenario, we have less dependency because the alternative use case is to make these applications talk between themselves instead of to a third party that stands in the middle, such as an ESB. This approach is typically more expensive. It takes a lot of time and it requires, which is most important, that developers who know both applications talk between themselves, maybe from different companies.
In our case, when we have the situation where Application A has to maintain a dialogue with Application B through the ESB, it may have different sets of developers. One for, let's say, Company Alpha doing the maintenance for Application A and Company Beta doing maintenance on Application B. They all have to talk to the API. The two companies don't need to talk among themselves, and that is something that reduces the dependency.
There's another use case as well. Let's suppose we have these Application A and B, and we replace B with another application called C. When this happens, we don't need to rewrite the whole integration. We only need to rewrite the integration between the ESB and Application C. So, there are some advantages down the road and overall, the dependence on developers slightly diminishes.
There are a couple of examples where using Fuse has benefited us. We have three applications that are running on top of Fuse.
With Fuse, we have been able to create a bidirectional integration between two applications in order to diminish the need for end-users to input or key in the same data into two different applications. This is what was happening before we suggested implementing a solution based on Fuse.
The benefits were immediate in the sense that there were almost zero errors because, of course, when you key in data in two different systems, chances are that you can make an error maybe in one system, maybe in the other system, maybe in both systems at the same time. When you are copying data or extracting data to Excel spreadsheets and then trying to import them into the next system, that is cumbersome. It takes a lot of time. It's manual work that can be completely avoided and the possibility of inserting errors is fairly high. So, on the data quality aspect of the equation, it has improved a lot and that was a benefit for the end-users. In our case, if we can avoid doing manual tasks, that is highly desirable.
We have also another case where we implemented a workflow that interacts with a repository management solution. This workflow was developed from scratch because one of the companies had a solution that was written for them because there is no package in the market for their particular business.
The industry comprises a very small number of companies in the world so there are no general solutions. We have to write them from scratch. But at the same time, we already possessed a corporate document repository where all copies of invoices, purchase orders, receipts, and other documentation have to be stored for disaster recovery purposes. Ideally, what we needed to do was have these two applications interact, which is exactly what we did by employing Fuse.
We have other use cases, for example, integration between an ERP and the corporate repository. For all of these integrations, instead of being point-to-point, we are using Fuse. This means that the maintenance of those applications was reduced. In fact, next year we are planning to change our ERP solution for several group companies. All of the documentation that is generated, for example, invoices to our customers, will be created by another ERP. We will only have to rewrite the communication between the new ERP and Fuse. This will result in less time to market and that all equates to savings.
We have other similar use cases but essentially, they all involve making two different applications talk between themselves or making a certain application store things in our corporate repository.
What is most valuable?
More than a feature, I would say that the reliability of the platform is the most valuable aspect. We have several servers and it is highly resilient, it is always available, and it requires very little maintenance. Of course, when something doesn't work, it's highly complicated. Because of the nature of the applications that we interface with, the product is highly complex but it's highly reliable as well. This is why we keep using it.
What needs improvement?
The documentation for Fuse can be improved because, while it is very detailed and extensive, it is not too intuitive for someone that has to deliver some kind of troubleshooting services. In particular, for installation, re-installation, or upgrades, I find that the documentation can be improved.
In some cases, resource consumption is an issue. It depends, of course, on the amount of bandwidth, memory, CPU processing power, et cetera, that you have. But time and again, we require more resources. An improvement in this area would be desirable.
Buyer's Guide
Red Hat Fuse
October 2024
Learn what your peers think about Red Hat Fuse. Get advice and tips from experienced pros sharing their opinions. Updated: October 2024.
814,649 professionals have used our research since 2012.
For how long have I used the solution?
I have been working with Red Hat Fuse for the last four to five years.
What do I think about the stability of the solution?
What do I think about the scalability of the solution?
Most of our use cases are about 100 users each. It works nicely for us at this scale but I can't speak about higher volumes.
How are customer service and support?
We haven't had the need to access technical support very frequently. If you have good developers, you don't need too much in terms of technical support.
For the times that we have needed them, we are satisfied with the support that we received. I would rate them an eight out of ten. Nobody is perfect and when we access technical support, we need an immediate answer. Of course, troubleshooting requires time and there is a gap between our expectations and the actual time that it takes for Red Hat support to deliver the solution.
Once you are waiting for a solution, you get a little stressed because, of course, the nature of technical support is that you have a problem, and you do not know in advance how long it's going to take them to solve it because they need to understand it, and they need to replicate it. So, it depends on your eagerness to wait or not.
Overall, it's very good.
How would you rate customer service and support?
Which solution did I use previously and why did I switch?
Before Fuse, we did point-to-point or one-to-one integration. We didn't have a prior solution that was replaced by Fuse.
How was the initial setup?
This initial setup is complex. The installation and implementation for the first integration, and perhaps most applications and projects that you can think of, is complex. The first time, it takes longer because you don't have the experience. It's more difficult. Then, you get used to it and you know the inner workings of the tool. You learn to know what might show up at a certain time and place, but for the first implementation, it's complex overall.
The first project took slightly less than one year to implement, perhaps between nine and ten months. In that case, the project required completing the installation, as well as the creation of the first integration.
What was our ROI?
Fuse has enabled us to deliver services faster, although this is not something that happens immediately. When we chose the platform, we decided that all integrations should occur on top of Fuse, but the ROI would show itself down the road and not in the first integration. For example, the first integration takes a while, then the second and third integrations also take time. After working with the system, implementing perhaps ten integrations that are running smoothly, then you have the velocity effect showing up. It's not something that happens in the first case. It does occur but the effect is not perceived immediately.
With respect to ROI, we have seen it but not as much as we expected. This is because the cost of the product is too high, in more than one sense. It's expensive overall but it is also too expensive upfront. For example, if you have to pay a million dollars, let's suppose over 10 years, the first installment is $100K, the second installment is another $100K, and the next eight installments are all the same. This is not the same as paying $1 million dollars upfront.
Let's say you save $500,000 by the fifth year, you reach the break-even point provided you pay in 10 installments. However, you will not break even if you paid $1 million dollars upfront and you see the benefits of half a million five years down the road. This is also something that has an impact.
Of course, the licensing model requires us to pay year by year, but the implementation cost occurs particularly during the first year and that is expensive as well. Overall, with respect to ROI, it is both yes and no. We have seen some benefits, but they didn't amount to the expectations that we had.
Of course, this is very difficult to see beforehand because you will run into obstacles over time that you cannot anticipate and it tends to be more expensive. It is something that could have been better but some of the obstacles were very difficult to anticipate.
What's my experience with pricing, setup cost, and licensing?
This is an expensive product. It costs a lot and although it's worth the money, the explanations that we need to give to our top executives are highly complicated. This is because the product is highly complicated when it comes to translating the benefits into money.
Regarding the licensing model, the problem with this type of product is that you are a hostage of the vendor. In this case, it's Red Hat but it could be any other. When the vendor changes its prices or the licensing model, you don't have options. You may have invested three or four years of development on the platform and if you are not satisfied with the new models, you have to accept them because the exit cost is huge.
We are not satisfied with the contracting aspect and we try to do our best but this, in general, happens with most of the software vendors. In particular, where you have either yearly subscriptions or when the product runs on the cloud. As things are, we are increasingly using both kinds of options. So, it's a sad fact but it's what happens. No matter whether we find it to our liking, we have to accept it.
Also, every renewal is complicated. In general, there are changes and the process isn't straightforward. Typically, vendors try to extract more money from the customers. I'm speaking about most of the software companies in the sense that you buy a product, use it, and you have to pay for technical support. In reality, you shouldn't have to pay for technical support. If you buy a fridge and it works, you don't buy technical support for the fridge because the fridge doesn't work or it has the risk of not working. If we need technical support, it's because the product lacks quality.
Again, I'm not talking only about Red Hat. I'm talking about any software product. The industry works in a perverse way and I can say that because I was on the other side of the counter. I worked for a world-class software company for several years and it happens the same way with all vendors. It's a problem for us as customers and the only way to change this is that agreements should be created differently, but it doesn't seem to be the case. As much as I would like this to happen, it's far away from what we can expect in the next few years. It has gone in the other direction.
Which other solutions did I evaluate?
We evaluated two or three other solutions.
In general, we make decisions based on three aspects. We consider the price, performance of the solution in the sense of suitability for our needs, quality of the product, et cetera, and third but not less important, comments from other users. In some cases, we consider the availability of local expertise by partners.
In the case of Red Hat, there are a lot of Red Hat partners overall but with deep knowledge of Fuse, there are very few in our region. That was something that caused us some doubt. The only factor that made us hesitate was this relative lack of availability of solution partners.
When you have very few suppliers, the price tends to be high, and maybe the response time that you need is not there because there might be, for example, a handful of technical resources of a certain vendor in your region, and they are booked for the next six months. We have encountered such difficulties, but the competition that we evaluated had also the same situation in that regard. Products such as Fuse and its competition are not widespread. You might find one Fuse implementation every hundred companies, and you can find a Red Hat Linux implementation in one of every two companies. It's obvious that you will find more Linux knowledge around than Fuse. This is how life works and you have to get used to that.
This relative shortcoming was applicable to all of the vendors because there are not too many Fuse or Fuse-like implementations overall, at least at the moment when we started, between four and five years ago.
What other advice do I have?
My advice for anybody who is considering Fuse is to research the market and talk to other customers. Try to make a good business case, express the expected benefits in figures, in money, as well as the costs. Try to have an honest, upfront negotiation with Red Hat, and try to estimate what will happen during the next few years. You want to understand the growth curve that might be involved and try to find use cases that are similar to yours because no two integrations are alike.
Had we done this at the moment we chose Red Hat, we might have not changed our decision but we might have been more confident. Of course, we didn't have that evaluation done at that point in time. We have no regrets, but this is what I would suggest to a friend that asks me how to proceed in this case.
Overall, this is a very good solution. The product quality is high. It's slightly complex upfront, but it's highly reliable. It has very good availability. It generates very few problems once you configure it properly. Of course, the configuration must be done carefully. As I mentioned, documentation could be improved and for small-scale implementations such as us, it works fine. I couldn't comment on large-scale implementations in the tens of thousands or hundreds of thousands of users because it's not what we have explored. Our implementations are smaller, but I could give a thumbs up to the solution, of course, considering its quality and what it delivers to cover our needs.
In summary, this is a good product and other than our comments about the documentation and resource consumption, we are really satisfied.
I would rate this solution a nine out of ten.
Which deployment model are you using for this solution?
On-premises
Disclosure: I am a real user, and this review is based on my own experience and opinions.