Your ability to create effective customer services processes are often constrained by the myriad of applications on your agent desktop – a typical customer service process may need to span multiple Windows and Web applications, none of which are integrated with each other, resulting in cumbersome process flows, rekeying of data and lack of integration - all of which adds up to lengthy call times, reduced accuracy (think customer call backs) and an overall increase in customer frustration. And reusing these applications in your SOA initiatives are even more problematic as they typically have no API, making accessing the data and functionality nearly impossible. The results are siloed applications on your desktop that do not work well together in an integrated and orchestrated manner.
Jacada Integration and Automation ("JIA") provides robust data integration and desktop automation capabilities on your existing Windows and Web applications. Desktop Automation provides process guidance, enhance your existing workflows, and eliminate redundant data entry while simplifying lengthy navigation sequences. Unlike many competing products, JIA steps beyond pure automation and provides integration capabilities allowing you to expose your existing closed application functionality as open standard web services for reuse in your SOA initiatives.
Even more importantly, all this is accomplished without modification of the applications, without access to their source code and without needing an API!
Whether it's a custom in-house developed application, or an off–the-shelf package, Jacada Integration and Automation is desktop automation solution and your path to rapid, risk free integration.
You need Desktop Automation if...
• Your agents struggle with complex or lengthy navigation sequences
• Your agents have to re-type data on multiple applications during a call
• The user experience could be improved through process guidance
• You want to reuse application functionality in new composite applications such as a unified desktop solution or as part of a broader SOA initiative.
How Does Desktop Automation Work?
Jacada Integration and Automation ("JIA") enables connectivity to Windows and Web applications without any code modification and without requiring access to the source code. If you can run the application, you can integrate to it!
Jacada Integration and Automation (JIA) is comprised of a development environment and a runtime environment. The development environment leverages the popular Microsoft Visual Studio IDE, allowing developers to create the solution in their favorite IDE. No more closed, proprietary solutions!
The runtime environment allows the solution to be deployed either in a "Desktop" mode in which the JIA scripts react to events occurring on the agent's desktop, or in a "Server" mode where the application functionality is surfaced as a web service API, ideal for SOA initatives.
• Desktop mode – The integration and automation of the application is done on the agent desktop, as if the agent were physically interacting with the application.
• Server mode – Applications are opened in multiple sessions (and optionally pooled) on a back-end server and exposed to the calling client via open standard web services.
In either deployment instance, JIA provides non-invasive access to the underlying applications, preserving all the existing business logic built into the user interface.
The Benefits of Desktop Automation for Your Business
By removing the underlying application constraints, your business can focus on delivering the optimal customer service experience.
Routine, complex or lengthy tasks can be automated, data can be automatically copied from one application to another and new business rules can be enforced, all without requiring modification to the applications, resulting in much faster implementation cycles with significantly reduced risk.
With Agents not needing to perform all these tasks manually, our clients typically reduce Average Handling Time (AHT) by 20% - 30%, increase First Call Resolution (FCR), increase sales revenue, and raise overall customer satisfaction.
The Benefits for IT
Your SOA initiatives are accelerated by rapidly exposing your legacy applications as reusable web services.
You can extend the life of your legacy desktop applications by reusing them in composite mash-up’s.
Using C#, your developers can continue to use industry standard tools and not be forced into adopting proprietary, limited languages.
JIA technology offers sophisticated workflow capabilities that allow it to do so much more than desktop automation. By leveraging the ability to monitor activity on the desktop, and interact with the underlying applications, users can be guided through complex processes with nonobstrusive UI overlays, providing Next Best Action guidance.
Solving Application Complexity
JIA solves the problem of application complexity. By automating complex navigation sequences, the user is spared the complex and time wasting steps of searching for information multiple screens deep, and from rekeying in data in multiple applications or screens within an application.
One of the most powerful JIA capabilities is its ability to surface you existing application functionality as open standard Web Services. These Web Services can be reused within a broader SOA initiative, meaning new life for your existing applications. And with orchestration technology, your new web services can be used to rapidly assemble new applications.
Citrix and Virtualization support
JIA is supported on Citrix. Desktops "exposed" via Citrix can be automated just like a native desktop, without needing to install any components on the Citrix server! This is particularly useful for BPO's who may not have ownership or control of the Citrix instance. Now the proven automation and process guidance benefits of JIA can be leveraged across your Citrix desktops in a completely non-invasive manner!
Desktop Automation Development Environment:
Uses Industry leading Visual Studio IDE
JIA leverages the power of the Visual Studio IDE by shipping as a Visual Studio "plug-in". After installation, the JIA development tools are conveniently located on the toolbar of the IDE. This allows developers to continue developing in the Visual Studio IDE without needing to move to a separate or proprietary development environment.
Recording a transaction:
The basic steps to enable a developer to quickly capture a series of interactions and generate a Web service are:
• Navigate the Windows application
• Define the fields
• Optionally add any additional logic to the script
• Deploy the service
The types of operations that may be used on an application include:
• The fact that the Application was launched
• Any button that is clicked
• Any text that has been entered into an edit field
• Any selection on a ComboBox, RadioButton, CheckBox and further controls
• Any mouse or keyboard operation on the screen.
• ...and many more
After the operation has been recorded, JIA will offer the developer the option of generating a web-service for the transaction and expose it automatically in such a way that it can be consumed by any web-service client. It is also possible to define various Input and Ouput parameters to the web-service, with support for both primitive types and objects. This type of transaction would greatly suit a backend service that is developed to run on a server.
The internal mechanisms that make all this possible are a result of Jacada's decades of experience in non-invasive integration. While the specific mechanism varies by application type, the concept is the same. By intelligently identifying controls on the user interface, JIA is able to intercept messages to these controls, modify values in the message and allow normal processing to continue. By working at this messaging layer, JIA is not sensitive to row/column or pixel level changes of UI controls on the screen, unlike other "screen scraping" solutions. JIA additionally supports playback of http streams to mimic request/response packets, in order to automate and integrate with certain web applications.
Desktop Automation Features
Support for Repeating Objects
Repeating objects are objects in an application that are displayed more than once, where their exact number cannot be determined in advance. During runtime, the number of these objects can vary and therefore, during development, capturing a fixed set of these objects is not possible. An example of repeating objects is a table of customer complaints for a specific day. JIA provides methods to handle these repeating objects.
Many vendors approach desktop automation and integration as a purely "screen scraping" exercise. It is important to offer both techniques for integration, both screen scraping and deeper control level integration. Screen Scraping has its uses for applications that are projected through a Citrix or Terminal Services session, where you do not have control or ownership of the underlying applications. Jacada Integration and Automation offer the ability to do screen scraping in those situations that warrant.
Dynamic Table Support
JIA Dynamic Table Supports allows for the extraction of data out of tables in a manner that is not dependent on the size (row/column) of the table or on the content. The JIA developer can dynamically iterate through a table and extract data from it dynamically, thus being tolerant to changes in the actual web table.
Open Standard C# code generation
The code generated by JIA is open standard C# code. This code can then be extended or modified by developers familiar with C#, obviating the need to learn a proprietary language. Unlike other products that produce "scripts" in xml, JIA provides the full power of the .NET platform.
Easy to use Object Hierarchy
Because controls are captured in the GUI Repository, JIA makes it easy to access and manipulate these objects. For example, below we open the Windows Address Book, choose to add a New contact and set the first name of the new contact, all in three lines of code:
JIA can monitor events in an application, such as a control receiving focus, text being typed in an edit box and so forth. When the Windows-based application is running on the agent desktop, WinFuse 'listens' to the user's interaction with the application, and waits for a predefined event to occur. Once the event occurs, it can be used to trigger additional processing.
Developers can choose to register for a particular event, such as "TextChanged" or "OnClick". Custom business logic can be placed in the event handler.
Below is an example custom event handler to simulate clicking the "Ok" button when the text in the field changes:
As depicted above, as soon as the text is changed in the editbox the event handler will obtain the application instance from the sender in the event arguments and perform the click on the targeted application.
JIA is able to automate applications on the desktop in a "hidden" mode, meaning that the applications do not have to be visible to the agent, nor do they need to have active focus for automation to be enacted on them.
Unlike other non-invasive integrations tools, JIA uses open standard C# to automate and integrate with applications. You are not limited to manipulating XML or, worse, a proprietary script based language. With the full power of C# and the .NET framework available to you, you can easily extend the power of your automation transactions.
Windows applications may have different internal messaging mechanisms depending on the language they were originally developed in. Likewise, Web applications today may be straightforward request/response based while some may utilize significant client side coding (think AJAX) to provide a rich user interface and asynchronous request/response packets. All of these applications have varying ways of integrating to them. JIA supports multiple protocols so that for any specific application, the most optimal integration technique can be used.
JIA is a flexible solution and was designed to allow us to support diverse environments. Please contact Jacada with your unique requirements. Previously supported clients include: Oracle Forms, .NET, Visual Basic/ActiveX, PowerBuilder, MFC, Delphi, Java, Citrix and most Web applications.
Async– multi app automation
JIA is built from the ground up to support full multi-threading. Multiple applications can be automated at the same time and events can be monitored on multiple applications at the same time. Web applications can run completely minimized or hidden as no focus is required to automate the application.
Transaction based automation (also in desktop interaction mode) allows the synchronization of different sets of automation pieces and the results returned (if any) from that particular transaction. JIA transactions can be efficiently managed with support for Parallel, Nested and Continues modes within a transaction.
Performance and scalability
JIA supports a decentralized deployment, allowing processing of events to be pushed to the agent desktop resulting in less server scalability requirements.