Dynatrace Reviews

We are using it to monitor our e-commerce applications and the full stack that our e-commerce applications run on. That includes both our Rack Room Shoes domain and our Off Broadway Shoes domain. We use it to monitor the overall health of the entire stack, from the hardware all the way to the user interface. And more specifically, we use it to monitor the real user's experience on the front-end.

What Dynatrace has really allowed our team to do is focus more on innovation, rather than on monitoring and bug-squashing. Now that we have a tool like Dynatrace, we can continue to do forward-thinking projects while Dynatrace is doing the monitoring and rooting out the root causes. We're spending a lot less time trying to find out what the problem is, versus letting Dynatrace pinpoint where the problem is. We can then validate and remediate much quicker. That's the impact it's had on our business.

The automated discovery and analysis helps us to proactively troubleshoot production and pinpoint underlying root cause. We recently had some issues with database connections. Our database team was scratching their heads, not really knowing where to look. What we were able to do with Dynatrace, because we had some of the Oracle Insights tools built into the database, was to provide, down to the SQL statement, what queries were taking up the most resources on that machine. We provided that to the database team and that gave them a head-start in being able to refactor the data so it was quicker to query. That really helped us speed up the user experience for that specific issue.

Dynatrace helps DevOps to focus on continuous delivery and to shift quality issues to pre-production. We are just now starting to use it in that way. When we first launched Dynatrace, we only had monitoring in our production environment. At that point we were using it as an up-front, first-alert tool for any issues that were happening. Now what we're doing is instrumenting our lower environments with Dynatrace so that it will allow us to monitor our load-testing in those environments, to find out where our breaking points are. So it does allow us to push out products that are much more stable and much less buggy because we're able to find out where our breaking points are in the lower environments. What this is going to do is allow us to do is push out, at a faster rate, more solid, less buggy releases and customer features, and allow us to continue to innovate on the next idea. We're just starting that journey. We just got fully instrumented in our lower environments in the last couple of weeks.

In terms of 360-degree visibility into the user experience across channels, we're only monitoring our digital channels right now, specifically our e-commerce channels. But we do have ways, even within the channel, to dissect by the source they came from. Did a given customer come from a digital ad? Did they come from an email? Did they come to us direct? It does allow us to segment our customers and see how each segment of customer performs as well. This is important for us because we want to make sure that we're not driving specific segments of customers into a bad-performing experience or to a slow response time. It also allows us to adequately determine where to spend our marketing dollars.

Another benefit is that it has definitely decreased our mean time to identification, with the solution and the Davis AI engine bringing the most probable root cause to the top. And within that, it gives us the ability to drill down into the specific issue or query or line of code that is the issue. So it has saved us a lot of time — I would estimate it has saved us 10 hours a week — in remediating issues and trying to find the root cause.

It has also improved uptime, indirectly. Because it gives us alerts early, we're able to mitigate issues before they're actually bigger issues.

The alerting systems are definitely the most valuable feature. The AI engine, "Davis," has proved to be a game-changer for us, as it helps to alert us when there are anomalies found in our applications or in their performance. We find that very helpful. There's still a human element to the self-healing capabilities. I wish I could say, "Oh, it's magic. You just plug it in and it fixes all your problems." I wouldn't say that, but what I would say is that the Davis engine gives us that immediate insight and allows us to cater to our solution so that the next time that problem arises it can mitigate it without a lot of human involvement.

Dynatrace's ability to assess the severity of anomalies, based on the actual impact to users and business KPIs, is really good, out-of-the-box. But it does an even better job when, again, we as humans give more instruction and provide more custom metrics that we're trying to monitor that are key to our business. And then, letting the Davis engine find those anomalies and push them to the top, especially as they relate to business impact, is very valuable to us.

We find the solution's ability to provide the root cause of our major issues, down to the line of code that might be problematic, to be valuable.

And we get a lot of value out of the Session Replay feature that allows us to capture up to 100 percent of our customers' real user experiences. That's helped us a lot in being able to find obscure bugs or make fixes to our applications. 

We also use real-user monitoring and Synthetic Monitoring functionalities. We use real-user monitoring for load times, speed index, and overall application index. And we use Synthetic Monitors to make sure that even certain outside, third-party services are available to us at all times. In certain cases, we have been reliant on a third-party service, and our Dynatrace tool has let us know that that service isn't available. We were able to remove that service from our website and reach out to the service provider to find out why it wasn't available.

We also find it to be very easy to use, even for some of our business users. Most of the folks who use the Dynatrace tool do tend to be in the technical field, but use is spread across both the business side, what we call our omni-channel group, as well as our IT group. They all use it for different purposes. I'm beginning to use it on the business side to show the impact that performance has on revenue risk. I can then go back and show that when we have bad performance it affects revenue. And I can put a dollar amount on that. So the user interface is very easy to use, even for the business user.

Dynatrace continues to innovate, and that's especially true in the last couple of years. We have continued to provide our feedback, but the one area that we get value out of now, where we would love to see additional features, is the Session Replay. The ability to see how one individual uses a particular feature is great. But what we'd really like to be able to see is how a large group of people uses a particular feature. I believe Dynatrace has some things on its roadmap to add to Session Replay that would allow us those kinds of insights as well.

We started using Dynatrace in September of 2017. At that time it was an older product called AppMon. But we quickly upgraded to the current Dynatrace platform the following year. We've been using the SaaS platform ever since.

It's been very stable. We've had very little downtime. In the last four years there may have been one outage. Overall, it's been extremely stable. Many times, Dynatrace is our first alert that we have issues with other platforms.

It's extremely scalable. We're one of the small players. We're running with about 70 agents right now. We've been at Dynatrace's conferences and have heard of customers who can deploy 5,000 agents over a weekend and have no issues at all. For our small spec-of-sand space, it's extremely scalable.

We are hosted on Google cloud. That's where all of our VMs are currently set up. Our database is there, our tax server is there. All of our application and web servers are there, and Dynatrace is monitoring all of that for us. We haven't encountered any limitations at all in scaling to our cloud-native environment. We can spin up new auxiliary servers in a matter of minutes and have Dynatrace agents running on them within 15 minutes. We're starting to play a little bit with migrating a version of our application into a Kubernetes deployment and using Dynatrace to monitor the Kubernetes containers as well.

We have plans to increase our usage of Dynatrace. We just recently updated our hosts. We needed to increase the number of host units so that we could put Dynatrace on more servers, and we've already just about used up all of those. So next year, we'll likely have to increase those host units again. And we're going to start using more pieces of Dynatrace that we haven't used before, like management zones and custom metrics.

Technical support has been great. The first line of defense is their chat through the UI, which is really simple. They're super-responsive and usually get back to us within minutes. We have a solutions engineer that we can reach out to as well, and they have been very helpful, even with things like setting up training sessions and screen-sharing sessions to help enable our internal teams to be more productive using the tool.

We were using a tool called New Relic and we were really just using it as a synthetic monitor to make sure the application was up and running, but we really weren't getting a lot of insights. When we decided that we wanted a tool that could give us more insights and that we needed a tool that could give us the ability to monitor more of our customers' behaviors, there just wasn't another tool like Dynatrace that we felt could do things as well as Dynatrace, through a "single pane of glass." We chose Dynatrace over New Relic at the time because New Relic just didn't have any solutions like it.

We haven't found another tool that can help us visualize and understand our infrastructure, and do triage, like Dynatrace. We haven't found one that can give us that full visibility into the entire stack from VM all the way to the UI. That was really the reason we picked Dynatrace. There just wasn't another tool that we felt could do it like Dynatrace.

The fact that the solution uses a single agent for automated deployment and discovery was the second reason that we chose Dynatrace. The ease of deployment, the fact that we could use the one agent and deploy it on the host and suddenly light up all of these metrics, and suddenly light up all of these dashboards with insights that we didn't have before, made it extremely attractive. It required a lot less on our part to try to do instrumentation. Now, as we add more Dynatrace agents to more of our back-end servers, we think we'll gain even more value out of it.

We started with AppMon, which was more of an on-premise version, where we were installing it, although it still was a one-agent. Then we moved to the SaaS solution, and it was very easy for us to migrate from AppMon to the SaaS solution, and it's been extremely easy to instrument new hosts with the agent.

We were up and running within 30 days when we were first engaged with AppMon. When we migrated to the SaaS solution, it maybe took another 30 days and might have even been less. I wasn't involved with that migration, but I worked closely with the guy who was. I don't remember it taking much longer than 30 days to migrate.

We had an implementation strategy. We knew specifically which application we wanted to monitor, and all of the hardware and services and APIs that that application was dependent on. We went in with a strategy to make sure that all of those things were monitored. And now we've progressed that strategy to start monitoring more of our internal back-end systems as well — the systems that support our stores, not just our e-commerce channel — to see if we can't get more value and maybe even realize more cost savings on our brick and mortar side using Dynatrace.

We have definitely seen return on our investment. It has come in the form of being able to produce more stable, less buggy applications and features, and in allowing our team to focus more on innovating new ideas that drive revenue and business, versus maintaining and troubleshooting the existing application.

It hasn't yet saved us money through consolidation of tools, but as we continue to find more value in Dynatrace, it does make us look at other tools and see if we are able to use Dynatrace to consolidate them. We have replaced other application monitoring tools with Dynatrace, but we've not yet consolidated tools.

Whatever your budget is, you can manage Dynatrace and get value out of it, but you need to manage it to what your needs are. That's the one thing we found. We did not budget the right amount to begin with. It has cost us more in the long run than if we would have been able to negotiate it upfront. But we didn't really know what we didn't know until we'd been using Dynatrace for awhile.

Your ability to catch your Session Replay is based on the number of what they call DEM units, digital experience monitoring units. That's where we were short to begin with. There is an additional expense to determining not just the platform subscription but also the number of hosts units that you want to run and the number of DEM units that you need to be able to capture all of the user experiences that you want. In our case, we wanted the ability to capture 100 percent. Maybe in another business someone would only be worried about capturing a sampling of the traffic.

We evaluated New Relic, AppDynamics, AppMon, which was the Dynatrace solution at the time, and we also looked at Rigor.

Dynatrace could do pretty much everything. It wasn't just the real-user monitoring piece of it. It was also the full stack health aspect. The Davis AI engine was probably the biggest differentiator among all of the tools. The Davis AI engine and its ability to surface the root cause was a game-changer.

My advice would be to jump all-in. There doesn't seem to be another tool that can do it like Dynatrace, and from what we've seen the last two times we've gone to their Dynatrace Perform conferences, they are dedicated to innovating and adding features to the platform.

We are not yet using Dynatrace for dynamic microservices within a Kubernetes environment. We are beginning to play in that arena. We're looking at tools that will help us migrate from our current VM architecture to a Kubernetes deployment architecture, to enable us to get more into a no-DevOps type of environment. But today, we're still on a virtual machine deployment architecture.

Similarly, we have not integrated the solution with our CI/CD and/or ITSM tools. That is on our roadmap. As we migrate and transition into a no-DevOps and continuous improvement/continuous deployment operation, we'll begin to use Dynatrace as part of our deployment processes.

The solution hasn't yet decreased our time to market for new innovations or capabilities, but we believe that we will realize that benefit going forward, since we'll be leveraging Dynatrace in our lower environments to find out where breaking points are of new features that we release.

We have half-a-dozen regular users who range from our e-commerce architect to DevOps engineers to front-end software developers. My role as a user is more of a senior-level executive or sponsor role. We also have some IT folks, some database administrators and some CI people, but most of our users are in the IT/technical realm.

We don't have a team dedicated to maintaining the solution. We do have a team responsible for it, though. That is the team that just helped instrument our lower environment with Dynatrace. We've got some shared responsibilities and some deployment instructions that are shared across three different groups. They're from IT, our omnichannel group, which is really our business side, and we leverage a third-party for staff augmentation and they use Dynatrace to help us monitor during our off-hours.

We have several uses for Dynatrace. Most of the time, we use Dynatrace for looking into potential site problems, investigating reported issues, and trying to replicate those problems in a test environment using the information provided by Dynatrace. 

We use Dynatrace for performance monitoring. Quarterly, we will specifically see if there's anything that we can optimize on the front-end of our website, so that's what you see and interact with on the web page. 

We also use it to get ahead of any potential problems in our stack. E.g., if Dynatrace is indicating a problem, we will look into it and determine if it's affecting users. Depending on its impact, and usually if it's impacting customers, we can use that information to decide on what we need to work on next to benefit the customer experience.

I use the tool as more of an analyst. I will use Dynatrace to show where systems need to be fixed, etc.

This solution is SaaS. We use Google Cloud Platform, where we just use their compute engines as far as our hosts. We also have a few services that are on-prem. Dynatrace works fine with both of them. 

The solution helps our DevOps to focus on continuous delivery and shift quality issues to pre-production. We recently got a staging environment implemented with Dynatrace. We are mainly using it for load testing at the moment. Dynatrace has been detecting failures, letting us know immediately what types of failures are occurring so we can catch them before releases. Our developers have been able to identify bottlenecks and other types of problems that they would not have been able to before by just using standard logging and analytics tools.

The solution give us 360-degree visibility of the user experience across channels, which is a great benefit. We're in eCommerce as a retailer. We are selling across multiple channels and platforms. We have a mobile app and a website. We even have other services which we may instrument with Dynatrace in the future. As far as our website and mobile app that we have instrumented with Dynatrace, it has all been very positive. 

The solution has decreased our time to market with new innovations/capabilities because we have been able to quickly identify areas that we can improve for new features and gather that data from Dynatrace. Then, we have been able to verify that our new features and releases are working as expected.

The User Sessions Query language has definitely been the most helpful with its key user actions and user session properties. Using those together, that has completely transformed how we're able to identify customers and their problems on our site. It has made a very big impact over the year.

Using synthetic monitors, we monitor our websites. We have two main domains. There are several plain HTTP monitors, then there are actual browser based monitors that emulate browser behavior. We use both of those types. We have several mobile browsers emulated under synthetic monitors that we use. Those ping our website every 15 minutes. On some of these synthetic monitors, we use multiple data centers to get an idea of geographic availability. We also monitor some of our third-party providers using our synthetic monitors. We monitor our customer support live chat server, which is hosted by a third-party, where we are given alerts if that system were to go down. We are also monitoring an email capture API that's a part of our website.

With user session queries, the main thing that we use that for (and the most valuable), is when we get a problem. If we get some type of a report, obscure problem, or Dynatrace reports a problem, we go straight to using the User Sessions Query Language to find sessions with Session Replay, then we replay those sessions to figure out exactly what the customer did and what conditions may have caused the problem to gauge the impact of the problem itself.

We also save user sessions queries into dashboards, then create different dashboards based on different projects to try and gather data. E.g., last year, we redid a part of our website and used Dynatrace sessions queries and Session Replays to verify that our customers were not having any problems or being confused by their experience. We wanted to verify that, which is one way that we've used the User Sessions Query Language along with the dashboards. We've also created some other dashboards that return custom metrics for us, which goes along, in some cases, with user session properties and user action properties. In that way, we're able to get a very granular look at certain statistics where it would be more difficult to get those numbers from our traditional analytics suite. 

The solution’s ability to assess the severity of anomalies based on the actual impact to users and business KPIs is a bit off. I have found that even though Dynatrace detects a problem and gives you a count and estimate of impacted users, this number is usually much higher than is actually the case and not fully accurate. E.g., I recently noticed an error. Every time someone would experience this error, Dynatrace would create a new problem and it would say, "Several hundred people were impacted." However, using Dynatrace's own tools (user Session Replay), then going back and actually tracing through these requests, we found much fewer people were actually impacted. In some sessions that Dynatrace said were impacted, when you view the Session Replay videos, you could see that the customer was not impacted in any meaningful way.

The solution’s ability to visualize, understand our infrastructure, and to do triage is helpful. I wish that you could do user session queries with those host level metrics and be able to create custom graphs the same way you could with user session data. They're both part of Dynatrace, but they don't feel like they're integrated together well. E.g., we're having an issue that has to do with just HTTP codes and we would like to marry that up with a user session query turning that into a dashboard. We can't currently do that because the User Sessions Query Language does not have access to the HTTP errors or HTTP status code data that is part of the hosts and infrastructure package. Otherwise, if you're just focusing on the infrastructure part it, I think it does a good job.

I have been using Dynatrace since February 2019.

I have noticed a few times where data collection did get interrupted. It was two or three times within the past year. Obviously, it's our monitoring system and we don't want that to go down at all. However, three times for no more than 30 minutes each time is pretty good.

The scalability has been able to meet all of our needs. We have not encountered any limitations when scaling Dynatrace with the Google Cloud Platform.

In the past 365 days, we have two websites that we monitor with Dynatrace, including mobile apps. We've recorded over 23 million sessions for Rack Room Shoes and 8.1 million sessions for Off Broadway Shoes. 

There are three users who are active users of Dynatrace:

1. The user experience architect, who is designing new interactive features and studying customer behavior
2. The product owner, whose focus when using Dynatrace is on the metrics, dashboards, and the user experience as far as using user sessions, queries and Session Replay. They may troubleshoot or look into problems as well.
3. The back-end architect, who looks into certain problems and figures out with Dynatrace where they're coming from. They use information from Dynatrace for writing more detailed support tickets.

I have noticed a few problems with the service before. I reached out to support and the system did appear to resolve itself on its own (after there was a problem). Then, the support staff couldn't see any further issues. The solution’s self-healing functionality works.

We ran into a problem where the Dynatrace JavaScript agent is returning errors, and it's very apparent that there's a problem. However, the customer support will ask us for seemingly unnecessary details instead of looking at our dashboard through their account to see what the problem is. They ask us for a lot of details not really related to solving the problem. As a result, we still have a few issues that were never resolved. They're not major issues, but they're frustrating.

The technical support is below average. They've solved some of the problems that we had, but it took several weeks to resolve almost each problem we had when they probably should have been fixed within a day or two.

There was an initial implementation of AppMon (another Dynatrace offering) before the current Dynatrace SaaS offering.

Dynatrace has definitely made an impact. We were never able to get granular data with any of our other solutions. They were all very disconnected and separate, whereas Dynatrace seems to have good integrations with our entire stack. There haven't been any problems getting additional data now that we have Dynatrace,

It is very easy to use and set up. It did take some customization to get it working for our sites, but after that, it's been pretty easy and straightforward.

The initial setup is complicated, but it's much less complicated than similar systems that I have used in the past. For Dynatrace's setup, maybe there were problems with how our web application was initially developed before I joined Rack Room, because there were a lot of features related to error reporting. It would report errors for things that weren't actual problems, etc. You have to configure it to get around those types of problems, but it's usually fine afterwards.

Over the past year, we've been tweaking Dynatrace. It's been a slow phase-in rollout as far as how much we rely on the data it's giving us back. 

I was involved in the initial implementation.

The solution has decreased our mean time to identification by about three days.

The solution decreased our mean time to repair by around a week.

There has been a huge increase in uptime. It's hard to say by how much for certain because we've made other development practice changes.

It is a great platform. We found a lot of value in setting up user session properties and user action properties, then being able to use them to identify individual problems/customers. We use that to sort of streamline the whole process of finding and fixing problems.

Biggest lesson learnt: Customers do not always behave as expected.

I would rate Dynatrace as an eight (out of 10).

We are using the solution in the operations space.

Our primary use case is production monitoring of complex business critical systems. Another use case would be performance testing of critical releases.

The solution uses a single agent for automated deployment and discovery, which helps our operations. It reduces the cost of ownership of managing Dynatrace as a tool set, ensuring that we're able to maximize the value from Dynatrace and monitoring is available. That's a big plus.

An example of how it helps is we are more proactive than we were previously, though we're not quite where we want to be. Engineers are talking more with the operations people, which is closing the loop. Our teams are becoming more customer centric.

The platform is very good at identifying potential issues, but each problem that surfaces in most cases still needs to be qualified and quantified by somebody who understands the system. Complex application problems, not infrastructure, surfaced by Dynatrace still need to be reviewed by somebody who understands the application logic or system architecture. For somebody who understands the platform though, issues can resolved in minutes as opposed to hours.

We have the ability to detect user action response time slow downs and their consequences, along with the back-end calls to third-parties. We are heavily dependent, for a number of products, on back-end service calls to other suppliers. Using Dynatrace, we are able to measure the performance of those third-parties. 

We are also using Dynatrace to right-size the infrastructure, especially on private cloud where we have to provision the resources upfront to save costs. Dynatrace helps us by finding how many resource we are utilizing and identifies how many resources we need to maintain for the level of performance and scalability that's required. This has helped us right-size in about 50 percent of our cases, leading to a reduction in cloud resources by 50 percent.

The solution helps DevOps to focus on continuous delivery and shift quality issues to pre-production. This helps with performance testing because our performance test teams are more aware of how product features are performing, which helps to prioritize our testing. It creates test cases so we're able to do more testing. Because Dynatrace helps us define the cause more quickly, this speeds up the time between test cycles.

The end-to-end trace is valuable for us to be able to assign responsibility to the right resolver group very quickly.

The user experience allows us to be able to gauge customer experience and understand the performance impact of our platform.

It has a very nice interface with an easy way to visualize the data that we need, making it quickly accessible. It is very easy to use.

As a platform consolidating tool, it covers 90 percent of the needs for most applications. In that respect, it presents a very high value for us.

We have used synthetic monitoring functionalities to poll. Mostly, it's around service availability and key functionality of a website from different geographic locations. 

The real-user monitoring is mostly used to gauge the difference in performance for multitenant applications, This is so we can discern if there are any local network or client-facing issues when we do a comparison between each customer. It is quite important for us to be able to identify a client-side issue, as opposed to a feature managed problem, because we're essentially providing managed services of business applications.

Dashboarding and having different templates available for more business reporting, or even other metrics, would be useful.

With Dynatrace, we use one tool where we would have used many, but we still have had gaps.

Three years.

It has very high availability.

When we started, we were measuring uptime in a different way, and then Dynatrace started measuring uptime based on services, as opposed to infrastructure. Initially, because we started using different metrics for availability, it showed us that we weren't available as much as we thought we were. This helped us to have better conversations with customers and improved availability from the customer perspective over time. 

We have 115 users, which includes Level 2 and 3 supports, service design, product management, cloud infrastructure management, software developers, software testers, and product architects.

We are only in an early phase at the moment regarding the use of Dynatrace. Currently, we are only using it on two critical platforms. Going forward, we're looking to expand to nine critical platforms.

Our adoption rate across the portfolio is low because we're still in a pilot phase trying to build out our business cases.

The technical support is excellent and very fast. Not only do I get a quick response, but they're also able to close the request off very quickly and satisfactorily with a fix.

Some of the feedback I get from our team, who are familiar with other tools: "Compared with other tools, Dynatrace support is excellent." 

The feedback that I get from people is that the initial setup was very straightforward and easy. It was amazing what information we got in such little time after deploying the agent.

In most cases, the deployment is quick. It takes a couple of hours.

For high-risk applications, which are business critical or high complexity, we would deploy Dynatrace. For medium-risk applications, we would consider using Dynatrace. It comes down to cost qualification for medium-risk applications.

The solution has decreased our mean time to identification. It has saved us from 10 minutes to a couple of hours.

Consider volume because that is where you will get the most benefit. Doing a point solution is not cost-effective.

There are additional Professional Services costs which ensure the solution is configured with meaningful names so you're getting the most money for your investment.

It is the easiest platform to manage in comparison to the competition, like Elastic Stack, New Relic, AppDynamic, Nagios, or Prometheus.

Without a doubt, I'd recommend Dynatrace for business critical applications and anything that's driving revenue.

Biggest lesson learnt: To recognize the most value from the information that Dynatrace provides, you need to make it available to everybody in the DevOps group. There is a wealth of data which can be exposed, manipulated, and consumed by other systems, not just what's visible in Dynatrace. This can also be used for inputs into other upstream platforms.  

Understand the demands within your environment and plan a pipeline, then discuss with Dynatrace. 

We're aware that there are use cases for notifications that can be used for triggering self-healing or autoscaling, but we are not using those yet.

I would rate this solution as a nine (out of 10).

Our primary use case for this solution is infrastructure and application monitoring. A total of 90% of our applications are on-premises and we are moving to the cloud, and this solution is helping us monitor that transition.

This solution has helped our organization on multiple occasions. The synthetic monitor came in particularly handy. We also deploy the solution to monitor hundreds of our customer-facing sites for any outages, etc.

The feature I found most valuable when it comes to this solution is the AI engine. It can correlate and collate different types of alerts and show us the most probable root cause.

I would say that this solution's reports are lacking a little bit, and because of this, you have to rely on API to fetch and pull data. I think they could have done a bit of a better job by providing a more user-friendly search from a reporting perspective.

I have been using this solution for about five years.

I would rate the stability of this solution an eight, on a scale from one to 10, with one being the worst and 10 being the best.

I would rate the scalability of this solution an eight, on a scale from one to 10, with one being the worst and 10 being the best.

I would rate the technical support of this solution a 10, on a scale from one to 10, with one being the worst and 10 being the best. The reason for this rating is that we pay for premium support with them.

Positive

I would say that five years ago when we did the initial setup, we had some issues. However, I think that this process has changed since then.

I would say that we have seen a return on investment.

We are typically about a version or two behind. We are on the managed solution.

Our model of deployment is on-premises. I would say there are a couple of thousand users of this solution in our company. We are also planning on increasing the usage as our apps migrate to the cloud.

I would advise other people looking into solutions, to do their homework beforehand and not assume that by deploying all the tools everything will automatically work, so there's still a lot of configuration involved.

I would rate this solution as a whole an eight, on a scale from one to 10, with one being the worst and 10 being the best.

Our primary use case is the consolidation of observability platforms.

Looking at Dynatrace's automation and AI capabilities, automation is generally a great place to start. In products where there has been no observability or a very limited amount, the automation can give a great deal of insight, telling people things that they didn't know that they needed to know.

Davis will do its best to provide root cause analysis, but you, as a human, are still responsible for joining as many of the dots together as possible in order to provide as big a picture as possible. As long as you accept that you still have to do some work, you'll get a good result.

I have not used Dynatrace for dynamic microservices within a Kubernetes environment in this company, but I have had an AWS microservice cluster in the past. Its ability to cope with ephemeral incidences, as Kubernetes usually are, was very good. The fact that we didn't have to manually scale out to match any autoscaling rules on the Kubernetes clusters was very useful. Its representation of them at the time wasn't the best. Other products, Datadog, for example, had a better representation in the actual portal of the SaaS platform. That was about three years ago, and Dynatrace has changed, but I haven't yet reused the Kubernetes monitoring to see if it has improved in that regard.

Given that Dynatrace is a single platform, as opposed to needing multiple tools, the ease of management is good because there is only one place to go in order to manage things. You deal with all of the management in one place.

The unified platform has allowed our teams to better collaborate. In particular, because of the platform consolidation, using Dynatrace has made the way we work generally more efficient. We don't have to hop between seven different monitoring tools. Instead, there's just one place to go. It's increased the level of observability throughout the business, where we now have development looking at their own metrics through APM, rather than waiting until there's a problem or an issue and then getting a bug report and then trying to recreate it.

It's increased visibility for the executive and the senior management, where they're getting to see dashboards about what's happening right now across the business or across their products, which didn't used to exist. There's the rate at which we can monitor new infrastructure, or applications, or custom devices. We had a rollout this week, which started two days ago, and by yesterday afternoon, I was able to provide dashboards giving feedback on the very infrastructure and applications that they had set the monitoring up on the day before.

As we've only been using Dynatrace in production for the past month in this company, the estimate as to the measurement of impact isn't ready yet. We need more time, more data, and more real use cases as opposed to the synthetic outages we've been creating. In my experience, Dynatrace is generally quite accurate for assessing the level of severity. Even in scenarios where you simply rely on the automation without any custom thresholds or anything like that, it does a good job of providing business awareness as to what is happening in your product.

Dynatrace has a single agent that we need to install for automated deployment and discovery. It uses up to four processes and we found it especially useful in dealing with things like old Linux distros. For example, Gentoo Linux couldn't handle TLS 1.2 for transport and thus, could not download the agent directly. We only had to move the one agent over SSH to the Gentoo server and install it, which was much easier than if we'd had to repeat that two or three times.

The automated discovery and analysis features have helped us to proactively troubleshoot products and pinpoint the underlying root cause. There was one particular product that benefited during the proof of concept period, where a product owner convened a war room and it took about nine hours of group time to try and reason out what might be the problem by looking at the codebase and other components. Then, when we did the same exercise for a different issue but with Dynatrace and the war room was convened, we had a likely root cause to work from in about 30 minutes.

In previous companies where the deployment has been more mature, it was definitely allowing DevOps to concentrate on shipping quality rather than where I am now, which is deploying Dynatrace. The biggest change in that organization was the use of APM and the insights it gave developers.

Current to the deployment of Dynatrace, we adopted a different methodology using Scrum and Agile for development. By following the Scrum pattern of meetings, we were able to observe the estimated time in the planning sessions for various tasks. It started to come down once the output of the APM had been considered. Ultimately, Dynatrace APM provided the insight that allowed the developers to complete the task faster.

The most valuable features for us right now are the auto-instrumentation, the automatic threshold creation, and the Davis AI-based root cause analysis, along with the dashboarding for executives and product owners.

These features are important because of the improved time it takes for deployment. There is a relatively small team deploying to a relatively large number of products, and therefore infrastructure types and technology stacks. If I had to manually instrument this, like how it is accomplished using Nagios or Zabbix, for example, it would take an extremely long time, perhaps years, to complete on my own. But with Dynatrace, I can install the agent, and as long as there is a properly formed connection between the agent and the SaaS platform, then I know that there is something to begin working with immediately and I can move on to the next and then review it so that the time to deployment is much shorter. It can be completed in months or less.

We employ real user monitoring, session replay, and synthetic monitoring functionalities. We have quite a few web applications and they generally have little to no observability beyond the infrastructure on which the applications run. The real user monitoring has been quite valuable in demonstrating to product owners and managers how the round-trips, or the key user actions, or expensive queries, for example, have been impacting the user experience.

By combining that with session replay and actually watching through a problematic session for a user, they get to experience the context as well as the raw data. For a developer, for example, it's helpful that you can tell them that a particular action is slow, or it has a low Apdex score, for example, but if you can show them what the customer is experiencing and they can see state changes in the page coupled with the slowness, then that gives a much richer diagnostic experience.

We use the synthetics in conjunction either with the real user monitoring or as standalone events for sites that either aren't public-facing, such as internal administration sites, or for APIs where we want to measure things in a timely manner. Rather than waiting for seasonal activity from a user as they go to work, go home, et cetera, we want it at a constant rate. Synthetics are very useful for that.

The benefit of Dynatrace's visualization capabilities has been more apparent for those that haven't used Dynatrace before or not for very long. When I show a product owner a dashboard highlighting the infrastructure health and any problems, or the general state of the infrastructure with Data Explorer graphs on it, that's normally a very exciting moment for them because they're getting to see things that they could only imagine before.

In terms of triaging, it has been useful for the sysadmins and the platform engineering team, as they normally had to rely on multiple tools up until now. We have had a consolidation of observability tools, originally starting with seven different monitoring platforms. It was very difficult for our sysadmins as they watched a data center running VMware with so many tools. Consolidating that into Dynatrace has been the biggest help, especially with Davis backing you up with RCAs.

The Smartscape topology has also been useful, although it is more for systems administrators than for product owners. Sysadmins have reveled in being able to see the interconnectedness of various infrastructures, even in the way that Dynatrace can discover things to which it isn't directly instrumented. When you have an agent on a server surrounded by other servers, but they do not have an agent installed, it will still allow a degree of discovery which can be represented in the Smartscape topology and help you plan where you need to move next or just highlight things that you hadn't even realized were connected.

The user interface for the management functions is not particularly intuitive for even the most common features. For example, you can't share dashboards en masse. You have to open each dashboard, go into settings, change the sharing options, go back to dashboards, et cetera. It's quite laborious. Whereas, Datadog does a better job in the same scenario of being a single platform of making these options accessible.

User and group management in the account settings for user permissions could be improved.

The way that Dynatrace deals with time zones across multiple geographies is quite a bone of contention because Dynatrace only displays the browser's local time. This is a problem because when I'm talking with people in Canada, which I do every day, they either have to run, on the fly, time recalculations in their heads to work out the time zone we're actually talking about as relevant to them, or I have to spin up a VM in order to open the browser with the time zone set to their local one in order to make it obvious to them without them having to do any mental arithmetic.

Personally, I have been using Dynatrace since November of 2018. At the company I am at, we have been using it for approximately four months. It was used as a PoC for the first three months, and it has been in production for the past month.

The SaaS product hasn't had any downtime while I've been at my current company. I've experienced downtime in the past, but it's minimal.

To this point, I've not had any problems with the scalability, aside from ensuring that you have provisioned enough units. However, that is another point that is related to pricing.

Essentially, its ability to scale and continue to work is fine. On the other hand, its ability to predict the required scalability in order to purchase the correct number of various units is much harder.

Talking about Dynatrace as a company, the people I've spoken to have always been responsive. The support is always available, partly because of our support package. As a whole, Dynatrace has always been a very responsive entity, whether I've been dealing with them in North America or in the UK.

We have used several other solutions including Grafana, Prometheus, Nagios, Zabbix, New Relic, AWS CloudWatch, Azure App Insights, and AppDynamics. We switched to Dynatrace in order to consolidate all of our observability platforms.

Aside from differences that I discuss in response to other questions, other differences would come from the product support rather than the product itself. Examples of this are Dynatrace University, the DT One support team, the post-sales goal-setting sessions, and training.

We're yet to have our main body of training, but we're currently scheduled to train on about 35 modules. Whereas, last year, when I rolled out Datadog, the training wasn't handled in the same way. It was far more on request for specific features. Whereas, this is an actual curriculum in order to familiarize end users with the product.

In my experience, the initial setup has been straightforward, but I've done it a few times. When I compare it to tools like Nagios, Zabbix, Grafana, and Prometheus, it is very straightforward. This is largely for two reasons.

First, they're not SaaS applications, whereas Dynatrace is, and second, the amount of backend configuration you have to do in preparation for those tools is much higher. That said, if we were to switch to Dynatrace Managed rather than Dynatrace SaaS, I imagine that the level of complexity for Dynatrace would rise significantly. As such, my answer is biased towards Dynatrace SaaS.

In my previous company, it allowed a very small team to manage what was a very fast-moving tech stack. In my current company, it is still very early.

The consolidation of tools due to implementing Dynatrace has saved us money, although it's tricky to measure the impact. The list price of Dynatrace was more than the previous list price spend on monitoring tools because the various platforms had been provided as open-source tools, were provided through hosting companies, or had been acquired as part of acquisitions of other companies.

The open-source applications that we used included Grafana, Prometheus, Nagios, and Zabbix. New Relic through Carbon60 in Canada, as an example, was provided through a hosting company. Also, we acquired a Canadian company or had been acquired as part of acquisitions of other companies, AppDynamics, in a Canadian company, for example, with us in the budget of the previous company rather than our own company.

The hope was that Dynatrace through consolidation would release the material cost of the administrative overheads of tools like Prometheus and Grafana and the cost of hosting infrastructure for solutions like Nagios, Zabbix, Prometheus, Grafana, et cetera. This means that it is more of an upstream cost-saving, where we would be saving human effort and hosting costs by consolidating into a SaaS platform, which is pretty much all-in-one.

Dynatrace's pricing for their consumption units is rather arcane compared to some of the other tools, thus making forward-looking calculations based on capacity planning quite hard. This is because you have to do your capacity planning, work out what that would mean in real terms, then translate that into Dynatrace terms and try to ensure you have enough Davis units, synthetics units, DEM units, and host units.

Catching those and making sure you've got them all right for anything up to a year in advance is quite hard. This means that its ability to scale and continue to work is fine but predicting the correct number of various units to purchase is much harder.

The premium support package is available for an additional charge.

At this point, we have not yet integrated Dynatrace with our CICD tool, which is Azure DevOps. However, in the future, our plan is to provide post-release measurements and automated rollbacks when necessary. Even further down the road, there's ServiceNow on the roadmap, which we're currently bringing in from an Australian acquisition in order to try and promote the ITSM side of the business.

There is nothing specific that has been implemented so far, although there have been general degrees of automation. When we get Agile, DevOps, and ServiceNow in place, the degree of automation will increase dramatically. For example, automated rollbacks in the case of deployment failure or change management automation through the current state of the target system are being included in the ServiceNow automation.

The automation that has been done to alleviate the effort spent on manual tasks is still very light because I'm the only person doing the work. I generally don't have time to do the ancillary tasks at the moment, such as creating automations. It's mostly a case of deploying instruments, observing, and moving on. When we come back to revisit it, then we'll look at the automations.

My advice for anybody who is looking into implementing Dynatrace is to make sure you talk constantly with your Dynatrace representatives during the PoC, or trial phase because there is invariably far more that Dynatrace can do than you realize. We only know what we know. I'm not suggesting that you let Dynatrace drive but instead, constantly provide the best practices. You will achieve faster returns afterward, whether that's labor savings, or recovery time, or costs from downtime. Basically, you want to make sure that you leverage the expertise of the company.

In summary, this is a very good product but they need to sort out their user interface issues and provide a more logical experience.

I would rate this solution a seven out of ten.

From an operational perspective, monitoring systems. We've primarily deployed it in production to give better awareness to application support teams of how their apps have been doing. We do have it deployed in pre-production as well, and are actively pursuing these cases in that space as well. It's just easier to sell to executives from the operations side first.

Mean time to resolution is probably the biggest improvement. Also, operational awareness is probably one I haven't touched on too much. I think in the past a lot of teams really didn't have a comfortable feel for how well, or not well, their applications were performing. You would get log files, things like that, just a small amount of perspective. In a lot of cases, people complaining was their first indicator of a problem and, really, nobody wants to be in that situation.

We started using this product about five years ago, and with AppMon. That was one of our first big wins, getting these big TV dashboards up all over the place. It really gave executives confidence that we did have things under control. At least we knew what was going on. It wasn't always the green check-mark up there, but we knew when there was a problem, before people called in and told us there was one. So that was a huge benefit.

• End-to-end visibility of the applications, since we have them instrumented. Understanding where the hotspots are in the applications. 
• Quick Fault Domain Isolations: When people are having a problem, understanding where to look, and letting all the other people go back to their day jobs. 
• The UEM feature, User Experience Management: Understanding how users are perceiving the application and then connecting that back into back-end systems to understand why things have gotten slow and then dealing with things.

Over the last year, one of the things we've had a challenge with is, we've used AppMon for so long, people are quite comfortable with it. We had a pilot of Dynatrace SaaS up and running for about a year, trying to transition application teams over to it: "Try this new tool out," - especially at microservices-based applications. And a lot of the features at the time that were in AppMon were not yet available, or worked differently, so we had some challenges in internally selling it. Since then, a lot of those features have been added into the new platform, and I'd say in some cases have leapfrogged over where AppMon is.

The one thing people really liked that we can do in AppMon is executive dashboards and, until recently, you couldn't even create the business transactions you need for the data at the back-end of those dashboards. But if I had to ask for one thing it would be: In the new platform, give me the ability to do dashboarding in the way it's done in AppMon, and I think that would bridge a lot of the missing pieces. If I could do the same type of executive dashboards on the walls, they would be happy.

As far as the new tool goes, we haven't had any issues with stability at all. I'm really impressed with the way they've architected it and made it much more scalable than the AppMon solution. 

We've had some challenges with AppMon in the past, mostly due to the top-end Dynatrace server not having an HA solution, which they're addressing now with the new version. So that's a big win for us as well. 

These things, when they first started out, were kind of neat and cool but they were never considered mission critical early on. Fast forward a few years to now, and nobody can afford the Dynatrace solution not being online. People are using it to support their apps. It is considered mission critical. So having HA built in, making this stuff rock solid, is very important to us.

So as far as AppMon, we knew where there were ceilings in the product. We've got a pretty big company and we hit some of those scalability limitations early on, to the point we were running about eight AppMon servers just for production load alone. One would never handle it. 

The thing that impressed me about the new Dynatrace Managed offering is that people are seeing, here at the Perfrom 2018 conference already, about 100,000 host limitation, at this point. But that's more than enough for us to handle our entire production infrastructure, so I'm looking forward to actually collapsing all of the AppMon stuff into one big solution where I can see, end-to-end, any app offering. Even if it crosses lines of business, you get full visibility. So I'm very impressed.

I wouldn't say we need to call them that often, the solution does not require a lot of hand-holding from that perspective, but we've had it for five years so there are always a few bumps in the road. We've had to call in for a few things, and they're really very professional. If we've needed to escalate issues, we've never had a problem doing that. Always been able to get to root cause, and in every case, been satisfied with the outcomes.

Five years ago, Wily Introscope was in place for a lot of our WebSphere infrastructure. At the time, we were actually looking at it more as an infrastructure tool. The guys supporting WAS, whether it be in Windows, AIX, Linux, or z/OS, needed something to give them a lot more visibility into what was going on, and Wily at the time just wasn't doing it. 

Wily Introscope was only lightly used at the time, but it just wasn't giving them the depth they needed. Realistically, nobody was using it. We had a product that was sitting there, unused. At the time there really was no APM-type thinking at all. It's kind of by chance since we moved to Dynatrace to satisfy that first requirement.

Since then, we've flipped it on its head, and we use the tool that much more from the app perspective. And that's really the way to do it. And we had no problem making that shift at all. We could still satisfy what the WAS team needed to do with the tool but get a lot more value out of it by giving app teams a lot more perspective. We've been able to get 500 percent more value out of it just by putting it with app teams as well.

One of the challenges, when we were looking through all the different solutions out there was, which one supported all of those things to give you that big picture? And Dynatrace met the mark. 

I was only loosely involved in the initial setup. At the time we brought Dynatrace in, it was one of my peers in the same larger group that was doing the evaluation. I was in the background, watching it. I then ended up inheriting the whole thing about a year later, so it was kind of good that I did have some visibility into it.

Overall, the initial setup was pretty straightforward.

We did a bake-off against some of the competitors at the time, and it was pretty clear Dynatrace was the best fit for our organization.

I know AppDynamics was one of the other ones we were evaluating, and IBM's offering, ITCAM. And given the different types of technologies we had to deal with, specifically mainframe, Dynatrace really stuck out as the one tool that could handle all the requirements we had at the time. And since then we've actually grown the use cases up quite significantly, and are even more happy with it.

When it comes to the nature of digital complexity, the role of AI - when it comes to IT's ability to scale in the cloud and manage performance properly - is huge. We saw it when moving to Dynatrace AppMon and started the Gen 2 platform and wondering how did we deal with problems just a few years ago without tools like this? Now we've gone into the Gen 3 platform space and really, with apps exploding from the perspective of complexity - as it's impossible to manually understand where all the moving parts are at any one time, where to look for a problem if it happens - AI really rolls all that up in a way that makes it useful, and we don't waste time trying to dig through things like we would have even with AppMon. So it's immensely important.

We still use siloed monitoring tools to some extent, and we've used quite a few of them. They have their place for what they do but, in reality, we've had to look at other aggregation-type tools and bringing feeds from each of those together. Let's say a Windows Server monitoring tool can tell you the CPU is higher, but it doesn't give you any perspective on what the actual impact is for the user of the app that's sitting on it. And that one server might only be a small cog in the wheel of the overall app. It's great at telling you what it does, but it doesn't go any further than that. You really need something that aggregates all those things together and has perspective. And that's really what app teams want. I think those tools are better served in the operations space, but then that's where they're stuck, they'll never go further than that.

If there was just one solution that could provide some real answers, as opposed to just data, the benefit would be that looking in multiple tools definitely slows you down. The fact that a tool like Dynatrace can bring all those things together and really help pop problems up right into your face is a huge time-saver. I don't know anyone that's got extra time on their hands at this point, so anything that helps us save time and get us to a resolution of a problem faster is of huge importance. Looking back, a few years back, trying to look at multiple tools to help us figure out problems, teams could spin for weeks because we'd have no idea where to look; classic war-room scenario, where everyone's pointing fingers at everyone else in the room, "It's not my problem." Dynatrace has really done a lot to help us get rid of those types of scenarios and be productive, really addressing actual issues.

I give it a nine out of 10. Compared to the other solutions out there, I'd still say it's top breed. It's great to see they're doing a lot more with the product on a big scale. But there are a few things they need to knock off the list to hit that 10; it's not perfect, but it's really, really good.

In terms of advice, the one thing that I've seen from other app teams internally: Do a PoC. It's much better to see your data in the tool than trying to demo it with easy travel or someone else's app. You just don't get the perspective of what they're looking at is some cases. Set it up, kick the tires, and give it a try, and that will win most people over.

I mostly just onboard different applications in the company under the Dynatrace platform. Occasionally, they will have issues, then I use AppMon in order to tell them what the issue is. It usually is something simple: The URL, this particular service is slow, or your database is not responding correctly. 

It is performing well.

It is different for me than other users. I like the PurePaths dashlet the most. This is mostly because (and I can count a handful at times where this has not been this scenario) as soon I open the PurePaths dashlet and sort by response time, there is the problem. Every time.

If the PurePaths dashlet pulls up 750,000 PurePaths, I really only needed to know about seven or eight of them. Then, being able to look into the code-level dive about it, that is just a sanity check. Just to make sure that it is the same issue multiple times, not a random anomaly where everything else was crap.

Also Errors dashlet, I use that a ton.

I would love to see a better data export, because AppMon's charting capabilities leaves a lot to be desired. The dashboarding capabilities leaves a lot to be desired. There are a lot of times, for example, at my last company, they wanted Dynatrace data in addition to a bunch of other stuff dumped into one place. It was not just performance metrics. The CEO wanted his business metrics in the same place as the performance metrics along with a lot of other stuff. However, Dynatrace could not export this type of stuff. 

You have about a 5,000 line limit or you have to set up your CSV file just exactly. DC RUM can do it. It might take like an hour sometimes, but DC RUM can do it. I would really like to see the ability to export, in Dynatrace and AppMon, in essentially in a nice format of whatever you want to whatever else. That would be fantastic.

For AppMon, there is always room for improvement: charting, dashboarding, and user management. However, that is pretty much our fault with LDAP. The onboard process itself is a pain, even though we have scripted so much it, it is just very repetitive. There is a lot of alerts and things like that out-of-the-box that do not need to be there or that just do not do the right things.

For Dynatrace, I feel like it just needs a lot more technology support. I know they are trying to essentially get rid of AppMon and move toward the Dynatrace way of doing things. However, we are a multibillion dollar bank. We are not up-to-date. We are not going to be microservices for a long time. We are not going to be container for a long time, and we are probably one the most expensive clients that they have.

We are the ones who are going to drive a lot of the money factor so they need to have that. They need to have integration between the current set of tools so we have the ability to onboard five or six apps, then we'll also put the AppMon agent on it and show people the difference between it. It needs to be better integrated.

All of our team will go to a five minute sales meeting, if they were like, "Look, you can do this with a script." We are sold.

We do not want to do any of the regular AppMon stuff. However, when you have to convince the CTO that we are going to completely rip out the entire monitoring solution which we just spent the last 15 years trying to get a process set up for, and now we are going to redo it. That is not going to go over well. That is not a good conversation. 

You need to have that ability to do MQ. I don't care who uses MQ, but apparently we do. If you can't look into those messages, then you just lost a half of our organization which can't be monitored with it.

With stability, I have never run into issues with Dynatrace causing an issue yet. 

I have run into AppMon causing issues. There have been a lot times when I have waited for a release. AppMon does the release, then it ends up taking down our application. Now, the fix is immediate, but I have already loss face. 

The last time, I took down the main application that lets you call tow trucks. It was just a monitoring loop, a simple thing. They fixed it in a patch. They knew about the issue and they told me immediately what the issue was. I got it fixed in 15 minutes. It took me six months to convince the team to install it in the first place and took me another seven for them to give me another shot at it. It was not a problem that showed up in QA, for whatever reason. So, I could not convince them that it does not exist anymore, because I could not show them any evidence that it existed in the first place. Let alone that I fixed it.

I have never been more confident in a tool because I've seen how easy it is for it to deal with the .NET Applets. That is a big problem in AppMon. Unless every single person is naming their Applets, the exact same way and following the exact same pattern, it becomes an issue. The new tool does not run into that at all. Similarly, you can script it so it just automatically blasts across the organization. As long as it has the PurePath capabilities, somebody who is running, for example, the actual web application that tells people their accounts, that might be a different, more in-depth use case for AppMon versus Dynatrace. So far, the scalability of the solution is phenomenal. 

Anytime I can't find the answer immediately in docs or answers, I just open a ticket. They are very good about giving you a response. 

Initially, I am talking about two or three years ago, I think they did not have enough personnel staffed there. Therefore, it would take them maybe two or three days to get to your ticket. Now, it is maybe the next day you will have a pretty reasonable answer and that is provided you did exactly what it says in the support ticket. For example, make sure you upload your support archive. Otherwise, you will burn a day and they will send you an email requesting you just upload this. That is shooting yourself in the foot, and that is not their fault. 

I have previously used siloed monitoring tools. I have used SiteScope. My current company uses ITCAM. They are okay. They get the job done.

At my previous employment, we used SiteScope and that was quite literally the way that I thought about it in day-to-day life, if you do not really give a crap about it, just put SiteScope on it. However, if you actually need to know if it is working, it needs to have Dynatrace.

I was always pushing for that sort of thing. There is stuff like Wiley where you are not getting 100% monitoring. There is another tool, one is a very new company, and it seemed to get the job done but that was only because we were using Citrix Xenapp. It was specifically able to decode the traffic for Xenapp and XenDesktop, which was what we were looking at. Apart from that, I have never had a situation where I was like, maybe we should not put Dynatrace on this. I have never run into that. 

I was not involved in the initial setup at my current company, but I was at a previous company.

For upgrading at my current company, that is in process. We are trying to figure out if it is better to blast it across the organization. We have five Dynatrace servers. They are all completely at capacity. They are all set at large. It is a really big deal for us to try to switch anything over. Right now, we are trying to figure out, do we just upgrade our collectors and hope for the best, or do we do it in QA and then in production? 

A lot of people do not run the right thing in QA. It is never the case that their QA is identical to production. So, is that a good indication? I have run into issues before when upgrading from 5.6 to 6.1 expecting that all the bugs were ironed out. That is when I took down that application. Now, I do not have confidence in this upgrade process.

For the Dynatrace Managed version, that setup process was incredibly easy. It took 15 minutes. 

Just go with Dynatrace. Just start with Dynatrace. Do not go into AppMon. Start with Dynatrace, because AppMon is going to give you so much extra stuff that 99% of your user base will not need it, including yourself.

You don't need AppMon. I am a hardcore AppMon guy and I am still saying this. It is a lot nicer to be able to start with the Dynatrace solution, be able to script everything, and start integrating the new thing than it is to try to do the old tool set. 

I started in the PDP program at Dynatrace. That was when they were still Compuware. Then they became Dynatrace, and I went to a different company, now I am at PNC. I have done the exact same thing for several years in different places.

In my current and previous positions, AI is not important when it comes to IT's ability to scale in the cloud and manage performance problems.

The previous company bought it, and they did not even set it up. I onboarded a bunch of apps. So, they were way too fledgling to try to start looking into it. 

What I would use AI for is if it could assist me in saying, "These are your common PurePath patterns." A lot of times in the ending part of an URL, they will have /apps, /data/, then they will put something lie the date or some big custom code. For example, we had one application for tow trucks, which would tell them the URL contained in PurePath, for the actual seven decimal place of the geographic coordinates of that tow truck.

This is not a good way to look at data. If the AI could tell me something about it, just mask it out, or just know this is the same type of data as these other ones and not worry about the extra text part of the piece. That would be the foremost use case for me. After that, I am not sure. 

I would need to use it a lot more to maintain my own trust factor in it before I would want to try to tell somebody that is asking me what the problem is. Just immediately saying AI says this. I do not have a high confidence enough factor in it, because I have never really used it.

If my organization had just one solution that could provide real answers, not just data, it would probably put me out of a job. Most of the time, when I get a ticket, they will ask me what the problem is. I will point out the problem, and it is something which is you need to code this better or you messed up these settings. Therefore, as far as helping me not have those mundane sort of tickets where I don't really want to waste my time with people. It is fine for the first few, but after the thirtieth or fortieth person, you tell them that you wrote this very poorly. It is better to just have some tool tell them that this is probably not the best way to do this.

That would be the initial benefit of the one solution. A part from that though, all I am doing is onboarding. The new Dynatrace already takes care of this. So, I am not really sure what my role would be afterwards. Right now, the APM is siloed off from the development teams. If you are going the full Dynatrace route with AI and getting the opportunity of the AIs already going to tell them what the issue is. Then, the APM team does not really need to exist anymore, apart from doing migrations.

Most important criteria when working with a vendor: That initial pairing of sales versus FTS. If I could reach out to them and get answers within a day, or better yet, within an hour. That is one of the best things because a lot of times that initial conversation can get derailed so quickly. You are not going to get more than five or ten minutes to pitch it to your boss. They are always at meetings. For example, my boss, at my previous place, I would be able to sit with him and talk to him about this thing. Then he would get, maybe, five minutes a week of his bosses level. That is the person who is going to sign the paycheck. 

Therefore, when he goes to a meeting, and it is a week later, he gives the spiel and has it all ironed out. Then, his boss asks him, "What about this?" Now, he does not know the answer, and I can't get the answer, then I need to get somebody on the phone stat to give him an answer. Otherwise, we have to wait another week. That is a big deal for us to have that communication open. 

Our primary use case right now is that we are dealing with the perfect days and non-perfect days.

We have a certain goal. E.g., for this financial year, we want to have 350 days of perfect days. The perfect days is where every application in the business should have low business impact, all applications should be available, and there are some other metrics that we want to know. 

We have constraints whether this is a perfect indicator, and saying whether it is a perfect day or not. There are some situations where one of the JVM is down, but the other processes, which do the same thing are up. In this case, pretty much there is no business impact. However, there is a technical issue, though no business impact. We can't sell this as a non-perfect day. Yet, it is a perfect day. 

Right now, we are using AppMon. Therefore, we are using AppMon to find out what metrics are available for us to see or indicate what is a perfect day or non-perfect day. That is one of the things. We are also using reactive stuff more for reactive stuff at the moment.

We are using AppDesk on user experience in indexes for customer satisfaction. 

We have been using for almost one year. It has been performing well.

The most valuable feature in AppMon is the PurePaths. Previously, we did not have this feature. The transactions using PurePaths are a good thing. 

We have like different teams like in a cross structure (DevOps, infrastructure, IT, product monitors, and developers), who recently joined the team. They are not aware of what are the missions their touching and what are the other components or services that they are depending upon. Because of all this, it has been very helpful for the developers who just joined the team. It can be explained, "Okay, this is our application. These are all the components that we are touching. Changing any of this might affect all these structural things. If we want to do any changes to this, we might need to put all this in our test cases, then QA it just to make sure we are not corrupting it."

In AppMon, the performance could be improved. That is the one thing I am most interested in. 

The other thing is the database. They might improve the database stuff a little bit more. The metrics and whatever that they are providing for database.

AppMon is lacking the AI that can be found in Dynatrace Managed.

Maybe last year, we had issues interacting with the MQs and the mainframe. They completely resolved this issue in 6.5, so we are now good.

We do not have downtime using Dynatrace.

It does scale well. 

Right now, we have some performance issues with Dynatrace AppMon, but the AppMon team is working closely with us registering the number of issues we are having and providing an extra set of tools that helps us to make the performance of the tool better.

One of the performance issue is when we are trying to bring up user data, such trying to bring up 20,000 or 50,000 PurePaths. That is where it is taking like five to seven minutes. When we are on a call, we do not have that much time. We want to make it approximately less than two minutes. They are doing a great job on that.

I would rate the technical support very well. They work with the inside their development teams to get us the best answer, as much as possible.

We have LoadRunner and Wiley. Our company has used Wiley for 13 years. 

They are one stop tools. If there is an issue, we have a team that always is on call: One should come from infrastructure, another from the data side, another from the product AVR, another from mainframe, and one person from Wiley saying, "These are the threats we have and open systems." So, we have five different people on a single call for a single issue. Sometimes we have 10 to 15 people on the call to figure out the issue.

With AppMon, looking at the translation flows and the PurePaths, we can with one or two members can identify and start to find where the problem is. So, this is a good feature.

The initial setup was straightforward.

We did have technical support help. During the first year, they have given us a resource, who has helped us in setting up the Dynatrace: getting some applications onboard, how to set up on dashboard, etc. This has helped us a little bit getting more familiar with the app and getting up to speed.

We have some demos on the Wiley, but they came very late to the table. Also, Splunk ITSI reached out to us.

For 13 years, we have been using Wiley. We definitely liked seeing the PurePaths being more helpful for us. As to Splunk ITSI, there is more configuration than AppMon. That is the reason we chose AppMon.

If you are implementing it for mainframe or MQ stuff, what are the things available and what are the other configurations that you need to set up.

Right now, we do not have AI capability. We are on AppMon. For us, it is about going and debugging the PurePath and looking into what is the issue: finding out the other use cases or root causes. It is pretty much manual. We are trying to moving from AppMon to Dynatrace Managed within the next six months. We are planning to do a debug on that. Going through all the videos and classes, it seems like Managed makes more sense for us and would be more helpful than AppMon.

If I had just one solution which could provide real answers, not just data, the immediate benefit for my team would be escape being pulled into a call and spending most of the time in analysis finding the root cause. If we are able to find the root cause and fix it immediately, that downtime would be less. That is the biggest benefit.

Most important criteria when selecting a vendor: customer support. That is most important, because companies do not have the tool knowledge initially, and someone needs support it or they need to hire someone. For companies like us, initially we onboard someone who has much more experience with the application inside the company, because we need some training on the customer support: when to support and what we need to do. 

The next one is writing the PoC, we have to find out whether it is satisfying all our use cases. So, if a system helps us with our issues, that would be great.