Author: Andrew Dvirnyk

The larger the system, the smaller the window for maintenance. We see that with our clients in the banking, utilities, and logistics and transportation industries. These big systems are running (and relied upon) twenty-four hours a day, 365 days a year. As a result, the window for any kind of system maintenance is very small. At the same time, the need for a system that runs well (and doesn’t abandon important jobs) is essential.

Banking System Challenges

Take some of our bank clients as an example. With banks, we apply maintenance activities about 1 – 2 times per month. Think again of data flow, and the way that fixes on the code work in systems of this size. In the context of these systems, each application uses different products that work on mainframe. As such, each application must be watched and maintained. And above all, we need to work with the shared goal of swift, effective, sustainable issues resolution.

Even with this clear, well-articulated goal, and with the best talent on the job, problems in business applications do occur. What further complicates things is that these problems can happen in different areas of the application. Or they can happen on different application at the same time. When they do, you are dealing with a pressing need to resolve issues the right way. And fast.

Think about a scenario in which Accounts Receivable is working on mainframe and needs to deliver data to accounting applications, but a process is abandoned. What happens? More importantly, how quickly can you fix it? And how do you keep it from having the same negative effects again?

Remember, your client’s customers are trusting your client (in our case for this scenario, a major banking institution) with significant sums of their money!

How We Used Appulse to Get Our Banking Client System Back on Track

Not long ago, we had a critical quarter end job that was abandoned. Because of an incorrect product configuration, the fault analyzer messages then sent us in the wrong direction to solve the problem. As a result, we initially investigated the problem the wrong way.

This is where developers, businesses, and end users often end up suffering. If you are going about understanding the problem the wrong way from the start (usually because you do not have the right tools to access and analyze the problem  or information on the problem is limited), you are “starting out on the back foot.” You are losing time and money chasing the wrong solution because you are attacking the wrong problem.

After a few hours of investigation, our engineers determined that the initial investigation itself was wrong and found the right solution. Now, because of Appulse, our engineers are able to access solutions to this problem and similar problems that we may encounter.

So, even though the solution itself was fairly straightforward, that does not mean that identifying the problem, finding the solution, and deploying the solution automatically meant that the system would never encounter a similar problem again. That is part of why maintenance, vigilance, and smart approaches are so necessary for keeping systems running efficiently and effectively.

Solving Applications Problems Once Is Not Enough

In fact, even after we corrected the issue, we encountered a similar problem on the bank’s system the following quarter. But because we had resolved the issue the way we did, and because Appulse kept a complete and accurate record of the solution process, our engineers were able to resolve the situation almost immediately. No loss of time. No loss of service. No stress at all for our client or their customers.

How were we able to do this so well and so quickly? Because Appulse is smart. Thanks to the data we feed it, Appulse is able to learn. Appulse learns the lessons from one situation and, in turn, it makes those lessons available as a possible solution to future situations. Our engineers can access this treasure trove of solutions the next time that situation or a similar one presents itself. And they can do that whether they were on the solutions team for the first incident on not.

Perfecting Memory is Smart and Sustainable

Even on our best days, the best developers and engineers have imperfect memories. As humans, we simply are not able to store everything we need to know to solve every single problem we encounter on a system.

Sure, in the moment, after just having solved a complicated business application issue successfully, as a developer, you are sure those steps will always stay fresh in your mind. We all know that feeling. On the day we figure out the solution, we are convinced we will remember it forever. We’re ready to tell stories about how we saved the day!

Of course, after some time, especially if we have not encountered a similar situation, we start to forget the details about how we got from Point A to Point B. Once we begin to forget (and we all do, and will) even when we face a similar situation, we are not able to recall all of the most important details. That is, if we are able to recall any details at all.

Let’s face it, developers and engineers are busy. We encounter multiple complexities every day, across a variety of systems for a wide range of clients whose customers all have very specific needs and wants. So, as focused, efficient, and creative as we are in the moment, we cannot possibly retain every single step we ever took to resolve the many, unique challenges we encounter. Those memories get pushed out by the issues and resolutions we deal with in the next hour, day, month, or year.

As much as we do not want to admit it, the archives of our own memories are imperfect. But the archive of Appulse stores everything we need to know. Then it uses that stored knowledge to learn more and to make it easier to solve the next problem. And the next one after that.

How Would You Use a More Perfect Memory?

One of the things we appreciate most about Appulse is the way that it empowers our developers and engineers to deliver more, faster, for our clients and their customers. This is chiefly possible because of that smart memory bank fueled by Appulse’s unique ability to learn.

The way that Appulse learns – and then makes solutions available based on that learning – makes Appulse like another member of our team. And it’s a team member that never gets sick, never takes a vacation day, and never retires. It is always available and always on target.

The impact of this additional, super-reliable team member goes beyond the ways it gives our developers and engineers the power to create and deploy system solutions faster for our clients and their customers. It gives them more time to work on new, creative solutions and ideas that will bring even more value to our business and yours.

So, what would you do with a smarter memory, and some extra time?

Author: Andrew Dvirnyk

From a developer point of view, the best way to understand the relationship between the developer and Appulse, is one of mutual learning and collaborative solution-making. We define Appulse as “smart,” and rightly so. It is able to learn, to respond, and to resolve enterprise-wide operational issues efficiently and effectively.

But we need to understand that, fundamentally, Appulse is as smart as the developers who work with it. What does that mean? For starters, it means that, even though Appulse recognizes issues on its own, it only resolves issues using solutions from “wise solutions database” which is initially loaded with a number of solution-templates and can be enlarged with solutions that developers load. So, while Appulse itself does not create a solution that is not loaded to it, it does trigger the need for a solution faster than a human might be able to notice there is a problem.

Over time, Appulse, thanks to an AI module, is then able to suggest solutions based on the solutions that have existed, and those solutions that have been  added to it. And based on the information that it collects about operational issues.

The speed and accuracy of issue recognition, the initiation of solutions, and issue resolution, is part of what makes the relationship between Appulse and the developers who use it one that is truly smart. It is also one that saves time and money, while keeping the most vital systems running well .

All that starts with learning.

How Appulse Learns

In the most basic sense, Appulse learns exactly the same way that each one of us learns. Every time Appulse encounters a new operational issue, it gathers information about what occurs and what the effect is. Then, just like humans gather and save knowledge in our “memory banks,” Appulse records and saves that information in its knowledge base with the help of an application support person using Appulse.

This is important, but it is only the beginning. Yes, Appulse stores the information related to specific scenarios across the enterprise. It gathers and saves knowledge. However, it also takes the next step, with the help of all the developers and engineers who use Appulse and work to make it smarter. And that next step is why we can call Appulse a truly smart resource.

In every new case – every time Appulse encounters a new scenario or operational issue – it also learns all the solutions that can resolve that issue. This is where the power of the developers and the engineers comes in to make Appulse smarter and more valuable to the enterprise. Developers assess the information that Appulse provides related to the operational issue. Then, the developers teach Appulse all the solutions that can work to resolve the issues that it reports. In this way, Appulse gets smarter with every issue it encounters. It continues to learn, increasing the knowledge base and improving efficiencies and responses over time.

So, the next time the same issue, or a similar issue, comes up, Appulse is able to search for necessary solutions, based on what it already knows will work. This is all based on what, with the help of developers, Appulse has learned and, effectively, remembered.

How Does Appulse Store Solutions?

Let’s return that idea of the human memory bank to understand a bit more about how Appulse stores solutions. Whenever a developer teaches Appulse how to resolve an issue, that developer loads the solution itself into Appulse. This is how Appulse comes to connect specific operational issues or scenarios with a specific solution (or a stable of solutions) that could work for those scenarios.

If you are thinking that there is a certain amount of complexity here, you are absolutely correct. One of the key values of Appulse is that it helps to simplify these complexities in a way that gets issues recognized and resolved more quickly.

Now, back to our memory bank. Appulse has a bit of an advantage here over our human brains. Our brains tend to forget important details and complicated, multi-step processes, even those that we have stored in our memory banks. Appulse, on the other hand, is designed to store, save, retrieve, and apply information efficiently. Every time a developer loads a solution into Appulse, that solution is stored in a template. Calling up and applying those templates to the right scenarios becomes a straightforward, efficient process.

Specific Templates for Specific Solutions

There are as many templates as there are solutions. And each is unique to the issue or issues it resolves. Because smart developers mean a smarter Appulse, developers fill each template with the needed parameters for exactly the situation at hand. This eliminates workarounds and trial and error. It also means that you will no longer face a situation where one Team Member is the only person who can fix a certain problem or apply the right solution to a specific operational problem.

Appulse stores that Team Member’s knowledge, along with the knowledge of all the other Team Members. So, whether that person is at work or available in the moment a specific issue arises, the problem can be resolved, thanks to the solution templates that Appulse stores and recalls.

As the developer, all you need to do is review the solution and run it.

Why Smarter Appulse is a Smart Ally

As streamlined a process as this is, we need to note again, that the complexities are real. That is why it is so important to have an Appulse that gets smarter by the day, along with a team of experienced developers who work together and share their knowledge with each other using Appulse.

One of the reasons that Appulse exists, is because the process of identifying issues and applying solutions to resolve those issues is as complex as it is essential to keeping large-scale businesses running. Often, the solutions in question are multi-stepped and complex.

But all that would be made more difficult without Appulse. For one, Appulse defines the problem quickly, often before it has the chance to have a significant negative impact on operations. For another, as soon as Appulse identifies that problem, it initiates a ticket that shows the problem needs a resolution.

That way, as soon as the developer opens the ticket, he/she sees the problem. But, they also see the solution Appulse recommends based on what it has learned. This helps move the resolution process along much faster, because the developer is not “reinventing the wheel” every time he/she encounters a problem. Making the process even more efficient – and more effective over time – the developer then submits the solution directly onto the mainframe.

Making Appulse – and Problem Solving – Even Smarter

We referred to the relationship between the developer and Appulse as collaborative. And that is exactly what it is. Appulse helps the developer see problems faster. And, based on its stored solutions, it helps developers see possible solutions more quickly, too. But Appulse only learns with the help of developers who are on a mission to solve problems.

In fact, the best kind of problem solving does not stop the moment that an issue is resolved. The best kind of problem solving gathers more information, provides feedback, and reviews scenarios to make sure that the next time a problem is encountered, it is resolved even more quickly.

The developer-Appulse relationship is this kind of problem solving in action. Once a solution is proven successful, the developer gives feedback and adds more information to Appulse. That creates a richer knowledge base for Appulse. As a result, everyone else who works with Appulse after that can choose from multiple solutions the next time the same or similar situation occurs.

Collaboration Continues

The developer-Appulse relationship is just a piece of the collaboration puzzle for keeping the biggest, most essential systems functioning optimally. Appulse enables large teams of developers and engineers to collaborate with each other through a centralized tool. Appulse makes it possible for colleagues to find solutions that other Team Members have imported. It also enables them to add new solutions other colleagues can use.

This makes the team smarter. It makes business applications smarter. And it makes work easier for everyone. In our next article, we are talking about how Appulse-enabled collaboration makes life easier for large teams. And how you might actually be able to turn off your work phone while you are on vacation!