Be an Automation Hero: Unleash Your Superhuman Abilities

Introduction to Automate's Superpowers

Automate's superpowers.

Automate takes the power of robotic process automation, or RPA, to new heights using four distinct capabilities.

These superpowers come together to turn anyone, regardless of technology or coding experience, from a zero to automation hero.

My name is Darell Walker, and I will be your presenter for today's session. At Fortra, I serve as a solutions engineer, supporting our automation solutions, which includes Automate. For today's agenda, we'll first take first talk about each of the four Automate superpowers and how we can use them in our automations.

We'll then discuss and view an example use case where we utilize these superpowers.

Next, we'll do a quick recap of the things that we've discussed today, and then finally, we'll answer any questions that may have popped up during the presentation.

A quick note before we begin about leaving questions in the GoToWebinar interface. Depending on which interface you're using, putting a question in the chat is a little bit different. If you're in the GoToWebinar browser interface, you'll see a section at the bottom that will say enter a question for the staff. You can go ahead and type your question there and then hit send. If you're using the Instant Join app, you'll first navigate to the question mark with a circle around it, type in your question, and hit the blue send button at the bottom.

And with that, let's go ahead and begin our workshop and dive into Automate's Superpowers.

Native Actions: The Core of the Automate Platform

First, let's start off with what is really the core of the Automate platform, which is what we call our native actions. So these are the drag and drop form based building blocks that allow us to interact with many common application and technologies that you may want to include in your automations.

So these would include things like Excel, PDFs, file transfers via methods like SFTP, SQL database actions, email, and even includes some conditional logic type actions, such as things like loops or checking for various conditions with if statements.

There's over seven hundred native actions built into the platform out of the box today, as well as the ability to code your own using our recently released custom actions SDK. So this provides some additional flexibility to code additional native actions for really virtually any platform out there with an API, an SDK, a CLI, or any way that you could interact with it programmatically, which greatly expands the capabilities of automate.

And this is all done in our intuitive and easy to use task builder, where you simply drag and drop your action into the building area and fill in the required fields. For nearly all of our native actions, there is no coding required.

By utilizing Native Actions, you can quickly build automations to interact and integrate with numerous other platforms and applications.

For example, perhaps you receive an Excel report in daily to a mailbox that you need to parse and import certain data to another system.

You could easily use Automate to set up an email monitor to watch for that report to arrive. Once it arrives, go ahead and download the attachment from the email and read in the data. Then use Automate's conditional logic to loop through the data, extract whatever is needed, and then maybe make an API call to some other platform to import that required information. And this would all be done with no human interaction or coding.

For any scenario where native actions can't be utilized, maybe there is no API we can use to interact with that system, or perhaps you may not have the technical expertise to do it any other way.

Automate Recorder for UI Automation

Automate does provide a built in step recorder that allows you to create robust recordings of your UI type processes.

While other RPA vendors may also have recorder features, Automate takes a superior approach to recording UI automations.

The step driven approach allows you to record each single step one at a time, mimicking how an end user may interact with that desktop application or web browser.

You can build and test each step of your process as you go, giving you that immediate feedback so you can be confident that your automation will work properly when ran.

In addition, the automated recorder makes updating recordings simple. You don't need to rerecord an entire process if something changes. Rather, you can simply modify each individual recorded step or add or remove steps as needed at any point in time. So, this makes the management of a UI driven automations fast and simple.

Finally, Automate allows you to interject any of the previous seven hundred plus native actions that we just talked about into your recording, giving you that seamless automation experience that more closely replicates your business process rather than simply mouse clicks and keyboard inputs in a browser.

We can use Automate Recorder to build out powerful UI automations do things like scrape data off of web pages or for manual data entry, where we don't have a database or API available to work with and have to use the GUI. For example, maybe you're in the IT departments and for any new or terminated employee, you have to go in and manually provision or deprovision accounts into various systems. But those systems don't have any way to interact with them other than going in the front door using a web portal. So, Automate can read in that user information, navigate that portal, and automatically provision or deprovision that user account for you. And it's rules based processes like these that our great canvas for UI automation.

Working with APIs

The third Automate superpower revolves around our ability to easily work with APIs.

So, Automate supports both the older web services or SOAP based APIs, as well as any of the newer RESTful APIs.

We also support many different authentication methods, including OAuth2, giving you flexibility when determining how to securely authenticate to these APIs.

And this is all handled using our simple to use HTTP action. So, so the complexities of working with API calls is masked. You simply need to fill in the various parameters to connect and pass information.

Obviously, you're gonna still need to have some basic understanding of how APIs work, but with Automate, you no longer have to write complex scripts or rely on your development team to build tasks to work with APIs. Automate's form driven approach makes working with them much simpler.

When available, APIs provide a fantastic way to integrate multiple disparate systems that otherwise may not be able to talk to each other. You can easily use automate to pass information back and forth using APIs, as well as parse out the responses to pull out any needed information.

Using the JSON and XML actions, you can take whatever that response payload of your API call is, easily pull out the required information that you're looking for, and utilize that information in the rest of your automate task as needed.

Automations using REST APIs tend to also be more robust as APIs, you know, typically rarely change as opposed to something like a button on a web page, for example. So, Impossible, using APIs in your automations is usually the better choice.

Many third party platforms that you probably utilize day to day in your organization probably have APIs that can be utilized.

Think of things like Microsoft three sixty five or Google, or even your ERP or CRM platforms or IT ticketing systems.

By leveraging the power of the APIs for these platforms, you can build robust, powerful automations, do things like sync data between two disparate platforms, or automatically pull and compile data to generate reports.

Intelligent Document Processing (IDP)

Finally, automates intelligent document processing allows you to easily capture data from sources that may not always have a predefined structure. This is called unstructured data and can be a pain to work with using traditional automation tools, as there's not going to be a lot of variance in where and how you have to locate and extract the needed information.

A good example of this would be things like AP invoices.

We have fields like the invoice dates, invoice number, vendor, line item details, totals, but this doesn't always look the same from invoice to invoice.

So, IDP takes the pain out of dealing with this type of data.

Using OCR, AI, and machine learning, we can easily classify documents, as well as extract that needed data from these unstructured data sources, such as invoices or mortgage documents.

IDP is able to capture the documents as they arrive, extract all the relevant data, and then update any needed systems, like an ERP platform, automatically.

And the best part is that there is no template building required. The system learns over time as it sees more of the same type of document. So, it's continually improving with accuracy, ensuring you always extract the correct information.

Let's go ahead and take a quick look now and see intelligent document processing in action.

So Automate's Intelligent Document Processing add on can be used to extract key data from documents that have unstructured data, such as, again, AP invoices. So it uses that AI machine learning, so it's intelligent enough to know what makes a document unique and can learn from user interaction with the product. And the first thing we're doing here is loading an invoice into what is called a batch. So, the system will take that invoice and then do capture the required data from the document by performing OCR and other data capture methods before presenting that data to the user in the data verification section.

Within the data section here, we can see that the system has identified almost all of the relevant details from that document here on that first pass. So it captures info from the header fields as well as line item details using that machine learning in AI.

You can see here that the vendor detail is missing. So it actually tried to pull it from the logo but wasn't actually able to recognize it there. But we can actually redirect that field to the remit section there at the bottom for a more readable line so it gets it correctly the next time. Most of the line item detail was also correct.

The only real issue there being that paid stamp that was in the way. So we can go ahead and clear that column out and then recapture the entire column values to help the system learn where to look for that correct info. That way, we can be more successful on the next pass. And at this point, all the information from that document is correct.

So we can go ahead and submit a larger batch to continue training the system for this particular vendor.

And you can see a larger collection of invoices are now getting submitted in a new batch, and that's going to go ahead and undergo that same OCR and data capture steps that we saw previously.

And now in the data verification, you know, we can see that from training that first document, the system has correctly identified all the relevant data on all of the invoices. Both single and multi page invoices are also identified properly and supported here. There's still some red text items that you notice, but that just signifies low OCR confidence. But that should increase over time as it learns, again, through seeing more of this type of document.

So now we can take this process data and maybe pass it back to Automate and take some additional actions such as inputting it to a database or maybe into your ERP system.

Demonstration of Native Actions and Recorder

Alright. So, now, we're gonna go and hop into the automate platform for a quick demo. We're gonna showcase how we can utilize our native actions, so so as to build UI automations with the recorder and also make some API calls. And then we'll take a look at a pre built example that's going to kind of tie these three areas together within a task that's going to capture some data from a website, save it into an Excel file, and then make an API call to send that file to, a OneDrive folder for storage.

So let's go and take a look at that now.

So here we are within the automate task builder. Again, this is our drag and drop development tool, so it allows us to quickly and rapidly build out our automation tasks.

And there's, again, two kind of primary methods that you can use to build here within the task builder. The first is to use our native actions. We see all of those listed here in this bottom left hand panel, and it's really as simple as searching through this list, figuring out what it is we want to work with, and then pulling that into our building area here in the middle. So, again, that could include things like working with SharePoints, working with PDFs, working with some basic OCR capture, even, FTP. So that could be file transfers via various methods, FTPS, FTP. And then we also have Excel, right? So, working with any sort of Excel document, performing actions there.

So, for example, maybe I want to go ahead and open an Excel file and read in some data. So I would utilize my Excel category here. I can also expand this arrow, and we can see all the available sub actions, within our Excel category, or we can simply drag the parent category here into the middle. And when we do that, we get our action properties dialog show up. So we can see we're in our Excel category. We can see all the available sub actions here on the left as well, which I can simply toggle through, and you can see the fields that are required to be filled in change.

So if I'm going to go ahead and open a workbook now that I could then use to to read our data, we'll simply choose open and create workbook here on the left, and then we fill in the field. So, typically, it's going to look something like this, where we have some combination of dropdown menus, blank fields, maybe some checkboxes, and that's really as complex as the majority of our native actions get. So, again, no coding required. It is all form based here.

So, to open this Excel file, we'll simply select open from our dropdown and we can utilize the file explorer button here to select a file, from our Windows system.

And typically, when you open any type of file or make a connection to something like a database or a mail server or an SFTP site, you are going to, create a session for that here. So we see that created. Typically, you can leave the default name, as is. This is going to indicate in this instance for any subsequent Excel actions. We can represent by session instead of having to potentially, you know, pass that file name and path in, maybe the passwords to open or modify. That'll all be saved here in our session.

So we can go and click Okay, and we get that first step added. We can easily see what it's doing. It's going to open this Excel workbook with this name and path. And, again, we're going to create that session Excel session one.

And now if that workbook is open, we can go ahead and actually work with it. So I want to read the data from it, so I'm going to grab one more Excel action here.

We'll choose a get cells sub action on the left, again, referencing that workbook by the session we created here above. We can simply select from that drop down, and then we select how we want to read our information. So the choices here being either a single cell of information or a range of cells of information, and that could be either by reference or position. So the difference there being however you prefer to think about working with an Excel file, whether that's, you know, by reference, which would be like cell, you know, a one, a two, or by position. So maybe column one, row two, for example.

I prefer to think of the Excel file as a reference, so I'm going to choose range of cells by reference here. And then we're going to create and populate what's called a dataset.

So, within Automate, a dataset is really just used to hold some information, throughout the task so we can continue to work with. And in this instance, it's some tabular type data, right? So data from this Excel file.

I like to prefix my datasets with ds4dataset, so I know what type of object it is when I'm looking at it later, and we'll just simply call it excel data in this instance.

Next, we'll go ahead and select where do we want to begin reading our information and where we like to end reading our information. And this is great if it's always a static range of cells every time this task runs.

Maybe you wanna go ahead and read everything from this from this workbook though, and then, you know, the number of rows could be different each time. But we could simply say, You know what? Start reading an A1, and we'll check a box here, auto detect the end of the file for us. That way, we're always grabbing the correct amount of rows, regardless of how many are in the actual file at the time of task execution.

I'm going to check the box down here as well. That first row of column names, I want to go ahead and capture so that we can utilize those. And again, most of the native actions are going to behave very similarly, simply figuring out what you want to work with, dragging that into the center panel here, and then filling in the required fields.

Once you're ready to go ahead and do some testing, there are some basic testing and debug capabilities built into the task builder as well. So we can see some run actions available up here in the ribbon bar, pause, stop. We could also insert breakpoints to pause our task. I'm gonna go ahead and execute this as is, which is really just going to go ahead and pop open our Excel workbook.

And then if we check out our Variables panel here at the bottom, we see that it did create our Excel data dataset.

And if we click the inspect button there, we can verify that and really just, you know, verify that it has the correct information that we were expecting, from the workbook. In this instance, it did, captured everything correctly, including our column headers here.

Alright. So, again, method one of building all of our native actions here, great for any type of business type process where we need to use, you know, application technologies that we have that kind of built in action for.

Anytime you have a system that you wanna work with, either, you know, maybe on a web page or some sort of desktop application, that's when you're typically going to want to leverage the recorder to build out those UI recordings. So at any point, you can click this new recording button up here at the top.

That does build or open up the, recording bar. It minimizes the task builder itself.

And the recorder bar just has a couple of buttons here that we can use. So we have control for working with desktop based applications, web for working with websites, position for when you have to kind of fall back on that traditional x y coordinate approach where you may be moving your mouse or clicking on some static x y coordinate set on the screen.

Using the Automate Recorder for Web Browser Actions

There's also an action drop down here, so we can quickly add things like pauses, keyboard inputs, or launch an app or a browser right from the recorder bar here. So, let's go and open a browser, and I'll go ahead and grab a URL that we can use.

And similar to when we created that Excel, session, we do the same here for our web browser. So, again, we'll just leave this as the default, web session one. Choose it as our browser we would like to utilize. I'll leave it as Chrome.

And we've clicked save and open. We see it went and added that step to the recorder, and it's going to go and run that as well. So, it's going to launch Chrome and attempt to take us out here, to our URL that we specified.

And once that page fully loads, we'll get our run successful message over here, within the recorder, indicating that we can go ahead and continue building.

And because this is a website, we're going to go ahead and use our web button here within the recorder. So, we simply click this button.

It'll go ahead and minimize the recorder, and then we just simply hover over the web page itself. So, anything that we can work with is going to get highlighted and labeled. So that could be scraping data off of the page, something like this title bar perhaps or maybe a paragraph of text if we want that, tables of data. We can also work with things like links, you know, maybe an entry in a drop down menu, insert information into fields like the search box, clicking on buttons. Right? So all of these things that we can handle with the recorder itself.

So if I want to go ahead and maybe put something in this search box, we'll go ahead and just wait for it to get highlighted here and then simply click on it.

Automate go ahead and goes ahead and adds that step. Then we simply change the action if needed. So it tries tries to interpret what we wanna do there, but in this instance, we're gonna go ahead and set a value, not get a value from that field. So we'll modify that action, and I'm gonna go ahead and grab a value here that we can utilize for testing. That does also support utilizing variables or dataset values in these fields, just so we can kind of see what's going on on the page as we build it out. We'll use a static value here to test with.

Automate Recorder's Step-Based Functionality

And, you know, I mentioned previously that our recorder is is step based, and it is kind of a little differentiating feature between, you know, our recorder and some of the the competition.

And, again, that kind of allows you to really build and test as you go so you can kind of ensure that things work properly, as you're building them out and not have to, you know, test over and over and redo steps, you know, after the fact. So as I click between these two lines, we can see this green play button show up. And I can simply click that play button here. It's going to run just this step. In this instance, attempt to populate our field with this value. And again, that gives us that immediate feedback here on the screen. And now we know that when this task actually runs, it's going to identify and work with this element on this page appropriately.

And now we just kind of keep building from here. Right? So more of the same thing. We click our web button.

We hover over the page. We find the item we want to work with. So, I'm going to go and maybe click our search button here to take us into our results from that search.

Change our action again here. We'll change to a click and we'll play it back to make sure it works properly.

So, again, very, very much kind of mimicking how an end user may be coming out and interacting with the page itself.

So, one more time, click the web button. We'll click into our result here to take us to the final page.

And, again, play it back. So you can kind of see very quick and easy to build out, or UI automations, right, able to easily identify what it is we're working with, and and take the needed steps here, just as a normal human will be working with the page itself. And once you're satisfied, you know, with your steps here within the recorder, you can close your browser routes. And if we click save and close-up here, we'll get back right into the task builder. You can see it created this recording region here, and we see all of those steps that we just built in the recorder have now been brought into the task builder and turned into our web browser action. So that is actually a native action category.

Benefits of Using the Automate Recorder

You could do this all manually if you wanted to. So you drag the web browser action in, select the, you know, action you wanna work with, what the URL is for the site we're on, what the HTML, attributes are and item is that we're trying to interact with on the page, how we're going to interact with it.

Obviously, much faster and less error prone to go ahead and let the recorder handle this, whenever possible.

So, again, using the recorder is is a very powerful tool for any of our UI type automations.

Working with APIs

Alright. And the last piece here, we'll be working with our APIs. So that is utilizing, again, our HTTP action. So we can simply drag that over here.

And we see here, you know, if you're familiar with APIs, you know, some of the common methods that you're going to utilize, right? So your gets, your posts, your puts, your patches, and then some less common ones that you may or may not need to use, but they're also included here.

So pretty straightforward process. Maybe you just wanna go and get some information from some API endpoints. We could use our get method here. And you see there's just a handful of fields that we really need to work with.

So, for example, if I wanted to grab some data about my Microsoft three sixty five account, right, I could simply take the URL for that endpoint, which is documented within, Microsoft's documentation for their API. Pretty straightforward there. Just paste the URL in, and then we can create and populate a dataset to get our result. Right?

So that way we can view, you know, what the result is, maybe take actions based off that result or pass it into our JSON, actions to be able to quickly and easily parse that out.

There's also some additional fields here if you need to change items like the content type or maybe pass in some sort of information in the header. So a common thing here would potentially be something like a a bearer token for authentication, which is actually required for this one, but I'm not going to pass it in. We're just going to go ahead and kind of show it as is.

So, as an example here, if I just run that step, just to kind of get an idea what that looks like, it's going to run, successfully, but it's not going to pass or pull back any information. If we look at our dataset though here, we can see, you know, what a response may look like. So we see all the information we passed in. Here's the data that we received back.

We can see that, you know, we didn't pass the correct information, so, obviously, we didn't get back a good result. But you can use all of this response information to, you know, perform some additional actions. So we see a four hundred bad request. We could typically indicate that that's something that we passed incorrectly, or you may see a four zero one unauthorized, meaning you don't have the correct permissions to perform that API call, or maybe a two hundred okay indicating that things were successful.

So you can use those types of responses, parse those out and take different corrective actions based off what you may have seen here, within that response.

Handling API Responses

Alright. So in the interest of time here, let's go ahead and, pop over to a kind of finished working example. It's really gonna kinda tie these these concepts together.

So, again, this is, a task that's going to, work with our Excel file that we just saw. Right? So that that tax data, that property data, it's gonna go out to our website that we're just working with. It's gonna perform the search for those account numbers in that file.

It's actually going to scrape the tax due amounts out of that web page. So, we see that, right here that it has been added.

So same type of thing here. It's identifying the item we're working with, and it's going to take out the value that we specified and store it in this variable we created called tax due. And once that gets pulled out, we're going to go ahead and write that back into our XM Excel file that we're working with here. So we'll utilize, again, an Excel action, our set cell sub action. Again, reference that here by session.

So when when setting or writing data back to an Excel file, you have a couple choices of what you want to write. It could be a single value or piece of information like we're working with here, but you could also write entire dataset. So maybe if you were to scrape a table of data off of a page, stored into a dataset, you could write that whole dataset to your Excel file or even a list of information.

So you see here, we're writing a single value. It is our var tax due variable amount that we captured, from the webpage.

And you may notice here all these percent symbols, right? So percent symbols within automate are going to indicate, that a variable is being utilized or a dataset value.

And we could typically access those.

When we're in a blank field, you'll usually see this little percent button here on the right hand side. And if you click on that, you get the expression builder that shows up here. And among other things, you see a lot of objects or folders here, one of them being our local variables folder. And that's going to be where all of your datasets are stored, all of their various values that exist within them. So you see all the columns from our Excel data dataset we created, right, our account number, property location, tax due amount, and then also all of your variables. So you can simply come in here, you know, double click, add in the variable that she wants to add to that field, click insert, and it'll add that in there for you.

So we're writing that tax due amount back to our workbook. Again, we're going to set that in here by reference into column C, which is what the C indicates here. And then you see this, Excel data current row value. So that's something that when you're working with datasets, automate keeps kinda keep track of for you. So when you're iterating, you know, through a dataset of information, it does go ahead and keep track of what row you're on as you iterate through that.

But what we have to account for here is our header row. So that's what this plus one indicates. So you can kind of think of this as we're going to start populating our data into column C2.

Utilizing Loops in Automations

Another thing we've introduced here is a loop. So I mentioned that in our native actions section that we do have some abilities to, you know, loop through data.

So we see here within our loop action, a number of ways we can loop through things. Right? It could be a range of information or range of indexes. So maybe we need to iterate through something ten times.

We could do expressions. So think of this as a, you know, do while or do until something is true. We can also loop through files or file contents, even windows on the screen. Right?

So lots of things here in this list that you can actually loop through, but probably one of the most common ones to utilize within your automations is a dataset loop. So that's what we're utilizing here. You kind of think of this as, again, for every row of this datasets or really every row of the Excel file, right, that we pull that information from, we're going to perform, you know, this subset of actions. So we're going to go out to our website, search for the account number, pull out the tax due amount, and write it back to our workbook and then repeat that process for every row of our dataset.

Once done, we'll go ahead and save and close that Excel file, giving you a new file name here, close our web browser out. We've got some actions here. These are to grab our authentication token for the API call we're gonna make. Not really gonna go much too much detail about that other than we're making a post request to grab it, and then we're using some actions here to pull out the piece of information that we need that's actually the token value.

And then we have our API call here to actually upload that file to OneDrive. So, again, this is, using our HTTP method to work with this REST API.

We're utilizing a put method in this instance. So to send information to an endpoint, you're typically gonna use either a post or a put depending on how they coded that API.

Microsoft uses a put for this instance, and you see here the URL we're sending it to. So I've got a variable here indicating what my base URL is, and that's really just to make this line a little shorter and more readable. So I that's typically gonna be common when working with APIs that you have some sort of base, URL that's used for all your API calls to that, that API. So, adding it to a variable can be helpful so you can, you know, not have this kind of run off the line.

Then we're sending this to the users endpoints.

This indicates the user's ID of the Microsoft three sixty five users OneDrive that we're going to send this to, and then you see the folder that we're going to send this to as well. So the root folder and then the property tax folder within the root directory.

We'll give this a new file name called just my new file, which is an Excel file. And then we have our content flag here on the end, which just indicates that we're sending the content, with this request. So we could also if we didn't include this, it would essentially just create a blank Excel file up there. Obviously, we don't wanna do that, so we're sending the content with it. And And then automate makes it nice and simple when doing this. We can simply say we're sending a file and then, again, specify that file name and path here utilizing the file explorer if need be.

Uploading File to OneDrive via API

And, again, you see we're creating a dataset with our results. We can utilize that. And I mentioned being able to send a particular content type or or header information. That's what we're doing here. This specifies the type of document we're sending. And then we have our authentication token, that we captured back here in steps thirty through thirty three.

That's for, you know, authenticating to the actual API endpoint.

So let's go ahead and run this, and we can kind of take a look at what it looks like in action.

Again, it's gonna go ahead and pop open our Excel workbook for us here. So we take a look at this.

It's gonna launch our website.

Again, that same website we're working with previously. It's gonna perform that search for each of these three account numbers that we see, grab out the tax due amount from them, and then write it back into the appropriate column here, within or appropriate row within column C.

Once this all finishes, again, it's going to iterate through each of these three, items performing that same search for each one.

And then once done, it's going to save and close this file, and save it as a new file so we can go ahead and upload it.

And I finished the third one. It looks like everyone paid their taxes this year, so that's great.

And then we make our put request to send the file. And we can see here in our output, everything succeeded. And if we hop over here to our OneDrive, this is our property tax folder that we specified within our root. And if I refresh the page, we should see now that my new file, and we can even click on it and open it up and just see that it does look identical to the Excel file that we just created.

Utilizing Automate's Superpowers

So, hopefully, that kinda ties everything together and showcases how we can utilize, you know, all three of the aspects, of the main superpowers there with the native actions, the UI step recorder, as well as utilizing API calls within your automation. So, obviously, a very powerful combination, allows you to build out some some fairly complex automations.

Alright. So let's go ahead and hop back over to our presentation now, and we're gonna just go and recap, you know, and review some of the things we talked about here as far as what the four automate superpowers are. So, again, automate really stands out for kind of several key reasons. First, we do have our API integration kit to really level up, you know, your back end automations with the ability to connect to APIs and easily process that data.

Automate's Recorder and UI Automation

Armed with Automate's recorder, you can build powerful UI automations from recordings of desktop applications and web browsers, again mimicking those end user actions like keyboard inputs and mouse movements.

Automate's secret weapon for faster automations are the seven hundred plus drag and drop native actions to common apps like, you know, Microsoft applications, Active Directory, AWS, and many more that we saw, giving you the tools to rapidly develop automations with these common apps and technologies.

Recap

And finally, bring brains to automate to brawn with machine learning and AI that captures and classifies unstructured data without code or templates.

By harnessing the power of these four automate superpowers, you can quickly and easily build out automations to remove those mundane, repetitive tasks that may be plaguing your organization.

You can easily integrate applications and systems while reducing human error and also lowering costs associated with those tasks. Your automations can run twenty four seven with no human interaction, allowing your employees to focus on meaningful work to help boost productivity.

Poll Questions: Q&A

Alright. So we are gonna take a quick poll question, and that should pop up here for you, within the GoToWebinar interface.

So, the question is, which superpower has the greatest potential to enhance your current automation efforts?

So the answers here, and you can select more than one, I believe, would be API integrations, UI automation, the native actions, or intelligent document processing.

And we'll give you guys just a few minutes here to answer that.

Alright. Perfect.

Alright. So let's go ahead and check and see if we have any questions. We just got one here.

Is using an API always preferable over using something like UI automation?

So that one is a little tough. I would lean towards yes typically, and that's really mainly due to, you know, simplifying the automation task itself.

So when you're working with APIs, there tends to be just less overall steps, and that's because you aren't having to account for, you know, navigating around a website. So there's just kinda less chances of something to go wrong, you know, when the task is running. And as I mentioned previously, APIs, you know, rarely change most of the time. So you don't have to worry about something abruptly breaking because maybe the developer decided to move something around on you. And even if an API does change, typically, they leave the older implementation in place for backwards compatibility anyway.

So, generally, again, those those tend to rarely need updated and just kinda continue to work.

One more here. It looks like can input be validated to account for error process responses?

It it can. So it's gonna depend on what the source of the error is and how we can actually capture it. But, typically, we have a couple ways we can do that. So, one of the things that I I didn't showcase today is that each step has a few tabs at the top.

So when you're building the native action out, there is, four tabs along the top, two of them dealing with error handling. So you can kinda build some, validation error handling in per step. And if you know a particular error code that may be popping up that you want to account for, you could either just continue or choose to maybe ignore it. Right?

So maybe you're, I don't know, for example, creating a a new file or folder, and you want it to just ignore if the file or folder already exists. Right? So, maybe that's going to cause an error, or it's going to ignore that as an error cause itself. So you can pick and choose kind of what will or what not cause an error and then what type of resolution you want based off any error that may pop up.

And, again, that could be things like just ignoring continuing on.

It could be writing things to a variable. Right? So maybe if there's some particular error message or code you need to capture, you can send that to a variable that you can then, perform an if statement on, maybe just check the value of it, and then take some subsequent error handling tasks.

So lots of ways you can kind of handle that, within the the action itself.

And then, again, u utilizing just if statements in general. So one of the examples was, when I was talking about the APIs previously, is is that you typically wanna capture your response into a dataset because you can't grab out those error messages. Right? So if you do happen to make an API call and you get, you know, something unsuccessful, right, or maybe you just wanna validate that did success or did succeed.

So if you, capture that response, verify that you know, do an if statement. If you get a two hundred okay, great. Ignore or just, you know, kinda continue on. If you get anything else, maybe we need to do some, you know, error handling there.

Maybe we do some subsequent steps. Maybe we're just gonna redo the API call itself. So, kind of a couple ways that we can account for that, but it it really kinda just depends on what's the source or what the action is that we're working with there.

Alright. I think looks like we have another one here. Is there a developer nonproduction version of Automate?

And if so, what is the cost?

There are a couple different flavors of Automate. So there is a a personal productivity kind of version, called Automate Desktop.

Similar Similar to what we saw today, there's no real differences as far as the task builder goes. It's kinda more on the back end, from the enterprise type version.

But, yeah, that is, available. And if you're interested, we do have some pricing information on our Forager websites.

Can we use custom ciphers not listed in automate in FTP and SFTP?

Not natively. So the the Cypher list does get updated periodically. I think they just updated again in the last release to include some of the newer ones.

If there's some that you would like to see that aren't in the list, you can always, submit those as a support ticket as a feature request, and they can look to get those added. One of the other things that you may be able to do, if you know that you have potentially an application that that already works with it, you could also maybe just utilize some of the actions to, you know, call that application, whether that's something like, FileZilla. Right? Have it just run FileZilla and perform the steps within the application there to perform it. Or the third alternative being that, with the custom actions SDK, if you have any sort of, you know, coding experience, you can use some of the the free libraries out there to build out your own FTP or SFTP action to be able to to handle those ciphers if need be.

Alright.

Let's see what else we got here.

Can automate link to two FA generated codes?

It depends on the two FA source. Right? So what our options are as far as dealing with and and grabbing those two FA codes. So we've got a couple tricks in the bag. Obviously, you know, two FA is kind of designed to ensure that it is a real person logging in and accessing things.

So, obviously, a problem for most automation tools.

If we have the ability to get a two FA code by email, for example, a common kind of workaround would be to have it send that code to an email inbox, and then we use the automate native actions to authenticate to that mailbox, grab out that message, grab the the code out of it, and then populate into the box, for example.

Some other kind of, workarounds that we've we've developed or come up with over the the years is if you have, TOTP codes, for example, you can utilize some of the either the, desktop based applications to generate those or store those like Authy. I think they're discontinuing their desktop app, but, previously, you could utilize that or maybe even the, browser extensions for some of these things to grab those codes out. We even had a very, a very, different one that we we worked with where they were only had SMS, but they were able to send that to, a Google messages application, and we were to access that via the web browser and grab it that way. So, some workarounds we've come up with, but, typically, it can be difficult depending on what options you have available to you.

And I believe that is everything.

One more. Is there logging available for troubleshooting task errors?

There isn't limited built in logging, and that's kind of by design as we don't want to know what's in your task, what it's accessing, right, because there could be some sensitive information in there.

You are free to build out to whatever type of custom logging you want. So, typically, customers will have a a logging template. Right? So, you can utilize some of the prebuilt functions that exist within the task itself.

So within the task at the top end of the function section, there is, task events that can be utilized. So, typically, you'll have, like, on task start. You're gonna create an a log file. They've read some header information to it.

Maybe start a timer to know how long the the task is running. And anytime an error pops up within a step or the task itself, you can capture that information and then generate it into the log file. And you can just write whatever you want to the log file, you know, overall. Right?

So maybe if you're running particular steps and you just want to write some output to the log just to verify what it is and keep that for, you know, historical records, that's something you could do as well.

Alright. I believe that hit all of the questions. If there's any other that pop up, we can definitely try to answer those, and get them out to you guys, after the presentation here.

And that should bring us here to the end of the presentation. So hope you found the content useful and learned something new about how to use the four main superpowers of automate. Thank you for joining, and have a great day.