UiPath IXP Reviews

The use case is related to invoice processing. We extract details from the invoices, and after those details are extracted, we use the UiPath RPA bot to process those invoices.

We have installed it on the client's machine and integrated it with the UiPath RPA bot. Document Understanding extracts the details from the document, and the UiPath RPA bot picks up this data and puts it in the system to process the invoice.

We are processing 2,00,000 to 3,00,000 invoices received from the vendors. They have structured data. There is no barcode on the invoice. There is structured data with date, invoice number, fax code number, amount, etc. It is a printed invoice.

The artificial intelligence or machine learning (AI or ML) capabilities of Document Understanding are very good. It reduces the development time. We can extract the required details quickly and with far more accuracy.

Document Understanding works very well with structured documents in different formats. I have not tried it with unstructured data.

About 70% of the invoices are completely (100%) processed automatically. The human validation required depends on the logic that we write. If the match is more than 85% to 90%, we do not require any human validation. If it is less than 85%, a few things are required from a human. The human validation process does not take more than a minute per document.

The average processing time used to be 6 to 7 minutes per document, but with Document Understanding, it has come down to 2 minutes, which also includes any human validation that is required.

Document Understanding has helped to reduce human errors, but I do not have the metrics.

Document Understanding has helped free up staff’s time for other projects. Approximately 50% to 60% of the time is freed up.

The entity-level extraction is very good. The workflow is also very good.

Its pricing can be improved. 

I have been working with this solution for three to five months. 

It is scalable. There is no doubt about it.

I would rate them an eight out of ten. They can have slightly better performance.

We use another solution. It is a local solution that we have. It is a lot cheaper, and the pricing model is also a little different. They do not charge you on a per-page basis. We saw an ROI with this solution because of its cost and charging model.

It is mostly deployed on the cloud. The cloud type depends on the organization, but mostly it is on a private cloud. AWS and Azure are the most popular ones currently.

I was involved in its deployment on a couple of projects. Its deployment is a little bit complex because you have to set up a private cloud, and then you have to install this entire product from the cloud. With a public cloud, it is relatively easy because the cloud services are provided by the product company itself, whereas with a private cloud, you have to take more measures.

In terms of the implementation strategy, we have to identify the type of document that we want to process. We have to determine the volume. We have to determine the variations. We have to classify them into structured data and unstructured data. Once all of those things are done, we start training based on the sample format. After the training is complete, we put it into the UAT mode, and then it will go to production.

Usually, we do the deployment as implementers. We take help from the product company's technical support in case we get stuck somewhere.

It requires one or three people for a maximum of three days. The scope of deployment depends on the use case. If you have use cases across departments, then it will be deployed across departments. The deployment would be dependent on the number of departments or countries. If additional countries are to be added, we have to deploy in that environment. We have done multi-country deployments as well. Multi-function deployments are not very common because, usually, all the applications work in the same environment.

Any maintenance is taken care of by the product company. There are upgrades, and then there are bugs that are found in the product. They need to update the product on a time-to-time basis.

We have seen time to value with Document Understanding. Outside India, it would be somewhere around 18 months, and in India, it would be somewhere around 2 to 2.5 years or 24 to 30 months.

Its pricing can be looked into because it is on the higher side for developing economies, such as India, where the cost of labor is a little cheaper compared to advanced technologies.

I would rate Document Understanding an eight out of ten.

We use UiPath Document Understanding for P2P processes to extract document information for ingestion, processing, and classification.

The key problem our clients faced, which we were trying to solve by implementing UiPath Document Understanding, was the large amount of unstructured data in the events. They want a solution that can solve this problem right from the beginning, from the document ingestion phase to the document classification and streamlining the document for the data taken right inside the documents. So driving all those analytics and the ROI in the end is a major key asked by most of our clients.

Our clients deploy UiPath Document Understanding both on-premises for our banking clients and also on the AWS cloud for others.

UiPath Document Understanding has helped us automate a large number of accounts payable processes for our clients such as P2P and O2C. 

It helps us process many types of file formats primarily PDF. We are able to process a large volume of documents using UiPath Document Understanding.

In our P2P process, we have encountered some handwritten invoices. The handwriting text recognition feature offered by UiPath is good, and it has been very helpful in converting these handwritten documents to a more structured format. Apart from handwritten invoices, there are other documents that require extensive merging and sorting, which has always been a concern for many of our clients. I believe that UiPath has effectively solved this problem.

Our clients process over 90% of documents using UiPath Document Understanding are processed straight through without human validation.

When we use Document Understanding to analyze data, the AI works in the background to process the document seamlessly.

The ability to integrate with other systems and applications is really great. I would rate it a nine out of ten.

It has improved our clients' cost savings and time savings, in turn improving productivity and providing a better ROI.

The time required to manually validate information depends on the type of document. A handwritten document takes longer than a PDF file and can take up to half an hour.

The average handling time has improved and is now under ten minutes.

It is very effective at reducing human error in identifying incorrect fields in documents. This is where I think it excels. We have seen a reduction in human errors by up to 90 percent.

UiPath Document Understanding has helped free up staff time for other projects.

We typically see a time to value after four to five days from starting the process, but again, this depends on the process.

Document classification is very good. We have received great feedback from customers who use it to classify bank documents, sort them, and generate formal documents. I think the overall presentation of the final document is amazing.

UiPath Document Understanding can improve its handwriting and signature recognition. We have also been engaging with other intelligent document processing companies such as ABBYY and Kofax, which have superior features for handwritten text recognition. UiPath offers a good solution, but ABBYY has far more support for handwritten text recognition, especially in the latest version.

It is still in its infancy and has room for more advanced AI features.

They need to strengthen their relationships with IDP partnerships.

They should expand its library.

I have been using UiPath Document Understanding for almost six months.

UiPath Document Understanding is a stable solution that our clients are comfortable using.

UiPath Document Understanding is highly scalable if I want to extend support to the maximum number of subprocesses within a single process. Therefore, I believe there is no scalability issue.

The support is good but sometimes the response time is slow.

Neutral

The initial deployment complexity depends on the document. Therefore, we must be cautious when integrating with third-party vendors. I believe it takes more time to deploy critical documents with sensitive data. We must be very careful when choosing a vendor, such as AWS or Azure, to ensure that we can integrate with them successfully.

We use a team of three to four people for Document Understanding deployments.

UiPath is more expensive than ABBYY and Kofax.

Our clients are concerned about the volume-based pricing model, as UiPath charges more than other vendors in the market.

I would rate UiPath Document Understanding seven out of ten.

UiPath Document Understanding requires maintenance from time to time, and we are currently experiencing a slowdown in the oral solution. Therefore, I believe that maintenance is required. Perhaps they need to develop a newer, more intelligent, and more efficient version, as Kofax and ABBYY have done. The same team of people that deploy UiPath Document Understanding also handles the maintenance.

There are other vendors who are excelling further in the intelligent document automation space. They offer more advanced capabilities and AI intelligence than Document Understanding, which is still an evolving solution. When we read customer reviews and have first-time conversations with clients, we notice that they often start by naming vendors like ABBYY, which are known for their technical expertise in the IDA space.

In a medical healthcare department, when we need to retrieve digital documents, we need to classify them. The first step is to use AI to understand what type of documents we're dealing with. Once we've identified the template, we can extract information using specific OCR tools. Depending on the confidence of the extracted results, we may need to apply additional OCR, use a more active tool, or pass the document to an agent for review if the AI doesn't recognize a specific element like the "person page of the commission." Finally, the extracted fields are classified within the system and organized into different folders. This is the process I'm using with UiPath Document Understanding.

Document Understanding can complete each document within one second.

It can be applied to the healthcare industry to streamline the processing of medical documents. This includes scanning and applying OCR to convert physical documents into digital formats.

We can tune the AI component to improve the quality and accuracy of the documents being processed.

Typically, the AI process involves several steps. Firstly, it recognizes the template, which essentially identifies the input format being used. Secondly, it applies rules configured in a JSON file. This file specifies details like the expected fields for the recognized template, such as name, age, date of birth, and security address. The AI then reads and analyzes data from the specified location based on the recognized template. It applies the predefined rules to extract relevant information and search for the required fields. If the input doesn't match any known template, it employs more general search methods to locate the desired information. This is the core functionality of the internal AI component.

Of the 1,000 documents we process, 90 percent are completely automated.

My three OCR tools each incorporate three AI components. These components work in tandem, with the activity determining which AI component takes the lead. For example, if the first AI requires a minimum accuracy of 86 percent and encounters text with 85 percent accuracy, it passes the task to the next AI component. This next component employs a different OCR tool in an attempt to achieve the required accuracy. If it still falls short, the task is then routed to a human agent.

Our integrations leverage robust API connection services. A single, secure authentication method protects access to JSON files. Requests are sent and product responses are seamlessly handled. This API-based approach provides faster and more efficient integration compared to manual interface interactions.

UiPath now includes a document understanding AI components, eliminating the need for third-party solutions like ABBYY. This allows for quick and automated extraction, analysis, and template recognition of information from various documents. By training the system with diverse examples, the AI component can become highly efficient, similar to ABBYY's global OCR capabilities. This is a significant improvement, as it eliminates the need for additional integrations like ABBYY within UiPath projects.

I found UiPath Document Understandings' ability to understand varying document formats to be good. I had no issues with the templates I was using.

Using AI and machine learning can significantly speed up the recognition of new formats, templates, customers, or entities introduced into our process. It is particularly beneficial when dealing with low-quality documents, which often require manual intervention. By implementing a machine learning model at the beginning of the process, the system can learn from successful agent solutions and incorporate them into future scenarios. Clear feedback, including agent ID and task details, further enhances this learning process. As a result, machine learning can help save time, reduce costs, and improve overall process accuracy. This makes it a valuable tool within UiPath.

Less than ten percent of processed documents require human validation. However, when customers provide input that falls outside pre-defined templates the usual 90 percent of cases, the system cannot recognize it and fails to notify agents. This means a new template will be implemented to include human-agent collaboration when training AI models.

The validation process depends on the specific template and the data being acquired. If all data is extracted from the entire template, the validation process can take less than one minute.

The manual document process took us around ten minutes and now with UiPath Document Understanding, the process is within seconds.

Since implementation, human error has been reduced by 30%.

UiPath Document Understanding has helped save 50% of our time in instances when no human validation is required.  

The quality of the input documents is crucial because sometimes healthcare providers prefer automated processing rather than human review. However, this preference depends on the complexity of the resolution required and the document type e.g., JPEG, TIFF. I find the quality of the input documents as the most valuable part of the automation.

At the end of the process, we classify documents in our external application, similar to a CRM system. This classification is based on the documents stored in the new system. The results of classifying patient documents within UiPath Document Understanding need to be more accurate.

I have been using UiPath Document Understanding for three years.

UiPath offers excellent technical support due to its high-tech nature and the complex needs of its customers. This support is crucial for several reasons. One such reason is the customer success plan, which provides dedicated API support and a specialist focused on existing customers. This fosters close communication between the customer and UiPath, facilitated by two individuals who actively monitor and manage the customer's needs every week.

Positive

Previously, we used manual processes for all our tasks. We transitioned to UiPath Document Understanding due to its integration of AI components. It is more flexible to our needs.

We saw a return on investment within three months of deploying UiPath Document Understanding.

The pricing structure is based on the number of robots installed. While a single robot may suffice for some customers, others may require more depending on their processing capacity needs and desired turnaround times.

The cost per license is significant, approaching ten thousand dollars. While not inexpensive, for high transaction volumes, the potential savings can be substantial.

I rate UiPath Document Understanding an eight out of ten.

In Italy, one of the most prevalent use cases involves automating the processing of invoicing cycles. The issue we aimed to address through the integration of this solution is essentially the manual input of data into systems by humans and the need for checks and balances between invoicing and other physical documents. Our organization is in the manufacturing realm. We primarily use Document Understanding to process invoices, specifically a common document in Italy known as the BDT. Regarding the document format, it includes structural elements like tables, checkboxes, and headers. Some documents may feature large tables, and the header contains essential information that needs to be extracted. In terms of volume, for a medium-sized or small company, we handle approximately ten thousand of these documents annually.

The advantage stems from the seamless integration of this solution with the UiPath platform. If a customer already has the standard, robust UiPath platform operating within their systems, adding these smaller modules is all that's required to enable Document Understanding. It functions as an integrated ecosystem.

It facilitated the automation of our data entry processes.

Approximately twenty to thirty percent of our customer's documents undergo full automation in processing.

In our scenario, Document Understanding operates independently as a standalone module, not integrated with any other systems. The robots, however, interact with the systems.

The average processing time, before and after automating with Document Understanding, improved in speed for a minute.

Human errors have been reduced by seventy percent.

Document Understanding has contributed to freeing up approximately seventy percent of people's time for other projects.

I believe the most valuable feature is the prebuilt algorithm for extracting information from foreign invoices. This efficient algorithm eliminates the need to create one from scratch.

It has the capacity to manage diverse document formats, including handwriting and signatures.

Leveraging artificial intelligence or machine learning capabilities is beneficial. These technologies excel in field identification tasks, even when adjustments such as moving or rotating the identified fields may be necessary. The primary benefit of artificial intelligence lies in its ability to handle various layouts.

Around 20 to 30 percent of cases necessitate human validation for Document Understanding outputs. The human validation process typically takes less than one minute per document.

There is room for improvement in handwriting processes. It should enhance the user interface for constructing extraction logic. It is not as user-friendly as other parts of the platform. An additional feature that could be considered is the integration with generative AI. The deployment process should be more user-friendly and streamlined. Scalability capabilities should be improved, as well.

I have been using it for two years now.

It offers good stability. The need for maintenance decreases with the highest level of stability.

Scalability is limited as it relies on the document layout. Integrating generative AI could potentially address this aspect. Moving an algorithm to another project without making significant changes can be quite challenging.

Our experience with its technical support is quite satisfactory. I would rate it nine out of ten.

Positive

The deployment process is not as straightforward as a seamless deployment, such as with App Studio. The number of people required for a project depends on its nature. Typically, one or two individuals are sufficient for most deployment cases.
Maintenance requirements vary depending on the projects. The team size can range from one person to five, six, or seven people. The deployment of this solution required one month.

I believe a six-month payback period is reasonable for the time-to-value. A shorter duration would be more favorable for customers.

I find the pricing to be somewhat on the higher side. User decisions are impacted by the pricing structure.

Overall, I would rate it nine out of ten.

We use UiPath Document Understanding for two purposes: extracting information from medical certificates issued by a prominent university in Singapore and processing invoices for a client in the logistics industry within their ERP systems.

We implemented UiPath Document Understanding to significantly reduce the substantial mailout effort. Approximately 20 full-time employees were previously dedicated to these processes, but after implementation, we were able to halve the number of full-time employees required.

We are capturing the header line items, which include the account number, invoice number, invoice date, and the line items: quantity, line item description, unit price, taxes, item number, and ZIP codes. This is a sales sector document. The medical certificate is an untested document, and we need to capture specific dates, the doctor's medical certificate number, and the student's name. We also need to check whether a checkbox is checked. There are no handwritten documents to extract.

Around 80 percent of our documents are processed 100 percent automatically.

Before implementing Document Understanding, the average time per invoice for manual processing, including invoice scanning and data extraction, was 15 minutes. Following automation, the processing time has been reduced to six minutes, with the specific duration varying based on the number of features on each invoice.

Document Understanding has helped reduce human error by 70 to 80 percent.

Document Understanding has reduced staff time by nearly 50 percent.

The best feature is pre-labeling, as it eliminates the need to manually label each data point. This saves a significant amount of time and effort. Additionally, the generated text is integrated seamlessly into the tool, making it easy to use. The documentation is also very clear and concise, making it easy to get started with the tool.

Over the past few years, I have observed that the invoice model consistently improves with each new UiPath release. There is still room for enhancement in capturing line items from invoices. This is one of the areas where I believe we can achieve near-perfect data capture. Unfortunately, the current accuracy rate for capturing line items is between 50 and 60 percent. This necessitates manual two-way matching, which is time-consuming and inefficient. I believe UiPath Document Understanding can still improve in this area, but overall, it is moving in the right direction.

Despite advancements in artificial intelligence and machine learning, there are lingering concerns about data privacy and security. These concerns can have a significant impact on users, particularly in terms of geographic restrictions and data policies.

The accuracy level we receive does not justify the price, as many competitors are offering much lower prices.

I have been using UiPath Document Understanding for three years.

While the stability is improving, it still needs to be enhanced in terms of model learning.

UiPath Document Understanding is scalable, but there is an aspect of training that requires attention. The model should be trained with a specific type of invoice to ensure optimal accuracy. For instance, if the invoices are in multiple languages and formats, the post-model training results may not be as effective as compared to training the model with invoices in a single language or two languages at most.

The technical support is good.

Positive

In the past, we used IQ Bot from Automation Anywhere; however, its output fell short of UiPath Document Understanding's capabilities. This discrepancy stems from the sheer size of the model we currently employ in the collection. UiPath Document Understanding's effectiveness is attributable to this factor. Additionally, UiPath offers superior analytical reporting capabilities, whereas Automation Anywhere falters in this regard. With Automation Anywhere, we were required to create multiple models, whereas UiPath allows us to utilize a single model for a collection of invoices with similar structures.

The deployment itself was straightforward. However, the deployment of the automation may have been more complex. In terms of the Document Understanding skills required for deployment, the process is straightforward. It doesn't require a lot of effort and can be completed in a day or two. For an experienced or certified individual, the deployment can likely be completed within a few hours.

To complete the deployment, a team of three people is required to work together.

The return on investment is seen within the first year of using the solution. 

UiPath Document Understanding is priced high compared to its competition.

I would rate UiPath Document Understanding nine out of ten.

Our clients experience time to value after approximately four months of usage because, initially, it takes some time to become familiar with the models and begin to see results.

The number of people we have using the solution is specific to the AP team or data finance team. Currently, we have two teams working on the solution.

Document Understanding requires ongoing maintenance in the form of model retraining. In the event of any encryptions, we may need to provide validation to the user. Additionally, we need to ensure that our models are regularly retrained.

Organizations need to carefully evaluate the scope and requirements of their Document Understanding initiatives. While existing Document Understanding models have demonstrated capabilities in specific invoice formats, it is crucial to test their performance across a broader range of invoice types. I recommend conducting a pilot test using a sample of 20 diverse but similar invoices to assess the models' accuracy and applicability.

Our primary clients are in the pharmaceutical and hospitality sectors. We recently developed a process using UiPath Document Understanding called 'Medicaid automation' to automatically download invoices and structured data from legacy systems. We then built an ETL pipeline to further process this information. Additionally, we have experience automating contract downloads and parsing data from contracts, even for structured data sources.

Automating processes using structured data is straightforward. However, in many cases, we need to involve human workers because data extraction is not very accurate. Therefore, we need a solution to integrate human input and structured data into the automation pipeline to minimize manual intervention. Additionally, when accuracy requirements are very high, we can also set up a user interface. Conversely, for less stringent accuracy requirements, we can create a fully automated pipeline. This is the core idea behind using UiPath Document Understanding. We aim to automate processes for functions like finance, resource management, and revenue management.

I work primarily in the pharmaceutical and hospitality industries. Within these industries, specific domains have different usage requirements. For example, in the pharmaceutical industry, I work with finance teams, and their focus on unstructured data includes tasks like invoice processing. Revenue management teams might leverage unstructured data for contract management, extracting key details for further use. Both finance and revenue management teams should consider how generative AI technology can streamline their workflows. In my experience, I've implemented an agent capable of extracting data from compliance documents and providing structured responses to users. Other use cases involved HR-related document queries and automated responses. Within the hospitality sector, I've worked on customer success and revenue management projects. On the customer success side, unstructured data related to loyalty programs could be analyzed for insights. We also explored automating email generation and streamlining tasks related to standard operating procedures. Revenue management in hospitality often involves contract automation. For a large hospitality company, I worked on a project to extract data from B2B contracts stored in Salesforce, pushing that information directly into their financial system. It's important to note that while I used unstructured documents as a foundation for these projects, not all of them specifically employed UiPath.

Using UiPath Document Understanding, we have successfully processed invoice documents and contracts. We are now expanding to handle various additional contract types based on specific use cases. This could involve rebate management, B2B interactions, or other scenarios. Additionally, we can handle other document types, such as per-case order documents and various SOP documents (compliance and operational). Finally, we have also explored applying Document Understanding to marketing materials related to sales rep automation, where product information can be leveraged to generate responses.

We use UiPath Document Understanding for many formats. The format of documents depends on their type. Invoices and purchase orders, for example, are considered semi-structured. This means they contain a combination of elements, such as tables, key-value pairs, and line items, but these elements can exist in different templates and with some variation between vendors. Contracts, on the other hand, are largely unstructured. While they may contain structured elements like tables, they also often include running text and information that is difficult to categorize in a predefined format.

We can fully automate the process for 95 percent of the documents. The more high-risk financial documents may need human intervention.

AI capabilities significantly reduce development effort for handling encrypted data while simultaneously increasing its overall scope. This allows me to achieve what was previously impossible with conventional APIs, even in advanced tools like UiPath. While UiPath also utilizes a broad model for data extraction, they are now expanding towards generative AI. Consequently, we benefit from improved extraction quality and the ability to extract data in the desired structure, all with minimal development effort thanks to AI.

When human validation is required, it takes one to two minutes for a five-page document.

Previously, reviewing a difficult document like a contract could take around 30 minutes, while an easier document like an invoice took 10-15 minutes. After automation, processing invoices got significantly faster, taking less than half a minute. This is because the complexity of invoices is generally lower compared to contracts. For contracts, automation was reduced to around three minutes. In simpler cases, the processing time could even be reduced to as low as one to 15 seconds.

The significant reduction in processing time leads to a notable decrease in human errors.

Our clients can see the time to value within the first three months.

The most valuable feature is key-value pair and table extraction. While we previously relied on UiPath and Amazon APIs, we've transitioned to generative AI for its superior performance on unstructured data. However, this shift presents a challenge: while UiPath and Amazon provided consistent output and value, generative AI outputs can vary significantly across different documents. This means we still need logic-based parsing for tables, even though they often share similar formats.

The UiPath APIs lack reliable table parsing.

The accuracy of document extraction depends on the document's original format. For rich text documents, the accuracy is generally good. However, scanned documents like PDFs or images present a challenge and often yield lower accuracy. Another challenge arises when dealing with multiple documents in a single image. This scenario is common in invoice automation, where a single image might contain several invoices. Furthermore, processing files containing multiple document types, such as multiple invoices in one file, can be problematic. Currently, the system assumes each uploaded file represents a single document or invoice, which is not always the case. To address these challenges, I propose enhancing UiPath Document Understanding to analyze the entire document, not just individual pages. This would allow the system to identify individual invoices within a multi-page document and assign extracted data to the corresponding invoice.

I would like custom key value integration instead of generic key values for extraction.

The cost of UiPath Document Understanding has room for improvement.

I have been using UiPath Document Understanding and other IDP products/APIs for four years.

UiPath Document Understanding is generally considered a stable product. If we encounter issues when using it in the context of a complex backend process, the problem is likely not with UiPath itself but rather with the specific process design and the components involved in its development.

The high cost of adding bots hinders our ability to scale UiPath Document Understanding. 

The deployment takes around five days for my team to complete.

UiPath Document Understanding carries a premium price tag, but its current technological capabilities may not yet fully justify the cost.

I would rate UiPath Document Understanding five out of ten.

UiPath Document Understanding requires significant ongoing maintenance, especially when it integrates with screens or utilizes user interface automation. This is because changes to the website structure are highly likely to cause these integrations to break. Backend automation, on the other hand, typically requires less ongoing maintenance. However, it is still recommended to dedicate resources to monitor the solution approximately 50 percent of the time. This proactive approach helps ensure uninterrupted business processes even after a proper initial development phase.

For automating cloud-native platforms, scripting often proves to be a more suitable approach compared to tools like UiPath. However, when dealing with legacy systems, UiPath might offer a more effective solution.

We use Document Understanding to process invoices, purchase orders, and addresses. It extracts data from a scanned structured document and converts that in a structured manner to a spreadsheet. Predominantly, we use Document Understanding for payroll, procurement, invoice processing, and also in the finance department. Document Understanding has multiple models for extracting data from receipts. Departments have different use cases, but it's mostly used on the finance side to extract invoice data. 

The volume of documents varies from customer to customer. When everyone starts using the product, they typically process between 10,000 to 20,000 in the first year. Once you've achieved a stable environment, you might reach around 500,000 pages in the second or third year. It depends on the project and the customer's budget because pricing is based on the number of pages. 

We are not talking about 100 percent data automation end to end. If our customers work with hundreds of vendors, they deal with various templates. If a new vendor comes in, there is a possibility that the model may not identify that particular document. It's also possible that the upload quality isn't that great because of a bad scan, so there is always a channel for manual processing to handle exceptions. 

When you implement Document Understanding, we may start with 40 percent automated and 60 percent manual. As it progresses and matures, the percentage gradually improves. We may eventually achieve 80 percent fully automated processing with 10 percent manual so that exceptions can be handled with the help of human intervention.

Traditionally, the operations team has done many of these activities manually. A human takes information from the document and enters it into the system. There are many challenges inherent in performing these tasks manually. One is human error. Also, a department might receive documents in the middle of the night, and no one is around to process them. Document Understanding enables round-the-clock support and automatic processing

The implementation is fast compared to other solutions.  Documentation Understanding is more flexible because it has the artificial intelligence to understand new formats when they come in. It may read the information automatically. 

The amount of human validation depends on the type of input document. For example, let's say we are extracting data from a passport. We had to extract data from the passport. The solution can properly scan the documents. There are 192 countries with different passports. The bots are already trained with all the different types of passports. 

However, if the solution encounters a new format for receipts, invoices, etc., it may not identify it properly. During COVID, we had to process PCR tests from different diagnostic centers with different formats, so we created a model to figure out whether the person had negative results, but if a different format came in from a new diagnostics center, we might not have enough data to train the model. 

It will scan correctly without human intervention if it's a well-established document type, but if there isn't enough training for the model, a human needs to come into the picture. Also, if the data input is not properly scanned because of its model input and all those things, and the system cannot understand it, then human-in-the-loop comes in. 

The time needed for a human to validate a document depends on the number of fields and whether the file is a PDF form, invoice, etc. If you only need to validate the invoice number, you can complete that in one or two seconds, but it will take more time to validate all the line items in every field.  

Document Understanding has reduced our processing time by around 70 percent. In some cases, it may be 90 percent. It obviously takes more time for an employee to process a document with three or four pages and pull the data from various places. Using a solution with an OCR component like Document Understanding is much faster. It frees up employee time because we're not using resources to punch in data manually. We can use those employees to do other things that require more human intelligence.

The solution has reduced human error because somebody previously opened this document manually and typed whatever they saw on the screen. Now, what is happening is the data extraction is happening systematically. If things look fine and the confidence score is high, it inserts the data into the system. If the confidence score is low, it shows the screen to the user and asks them to correct it. Instead of merely typing the information, the user verifies what the solution has done. It's easily a 30 to 40 percent error reduction, and the operational efficiency is drastically increasing. 

Invoice processing is the most valuable feature. Most of my customers use Document Understanding for invoice processing. That's one of the most common use cases. Typically, each customer starts their RPA journey with the finance department because that's the area where you can see the most benefit. 

It can extract checkboxes, signatures, and printed documents. The extraction and conversion of printed letters is perfect. Document Understanding can also process handwriting and signatures using a machine learning model on the backend. UiPath's product team is constantly training this model continuously. Every two weeks, they are training it with a new set of data, so the model is constantly becoming more mature. I've seen a tremendous improvement since 2021.

The solution's machine learning model gives it the flexibility to accommodate documents with varying structures. Before document understanding came along, data extraction was done using template-based extraction tools. They created a machine-learning model that can be retrained for any number of templates. If you are actually not using machine learning, you will not explicitly identify fields like "Bill To," "Ship To" etc. You have to tell it the location where you want to find data. 

UiPath has already trained its machine-learning model, which has seen these types of invoices and trained the solution. You're building a better solution that requires less effort to implement because the product does a lot of that work for you. The deployment time is faster. It's more intelligent than conventional coding, which is just listing a set of rules. Everybody needs flexibility. It's not enough to have a solution to handle documents in a particular format. Whatever you do, it should have the intelligence to understand data in a semi-structured format even though things are returning in a different manner than the one that came before. 

Document Understanding's handwriting comprehension is improving, but it's still not as good as printed documents. Machine learning models, in general, are becoming mature, but it's still not to a point where I will give it five stars. I may give it a two or three. It is still not advanced enough to identify whatever handwritten content you give to it. It can process handwriting, but you need a human to validate it. With more training, it will become more automated. It will be better by 2025, but it is still not mature enough

Similarly, there is still room for improvement in reading printed documents. Ideally, if you have a model, Document Understanding should be able to extract every field from there. That's what customers expect. 

We have used Document Understanding for about six months.

I rate Document Understanding seven out of ten for stability. It has some room for improvement. 

I rate Document Understanding seven out of ten for scalability,

I rate UiPath support four out of 10. Their support has degraded badly. Presently, they are mainly focused on closing tickets. They have trouble communicating with our business users and end up closing the ticket because they don't understand what the issue is. It's a problem because the customer will lose interest in the product if they are not getting technical support. 

Neutral

UiPath can be deployed on the cloud or on-prem. The infrastructure costs of hosting it on-prem are high. We have done many cloud deployments, but I would say it's not that easy. Normally, we subscribe to the SaaS version of UiPath and configure it for the customer. UiPath has a cloud instance, which is a SaaS offering. I believe Document Understanding is hosted in Azure, but the customer can opt for AWS, Google, etc. There are no restrictions if customers want to put it on their private cloud.

An on-prem installation takes about two or three weeks depending on the complexity of the environment. Cloud installation is plug-and-play, so you can get it up and running in a day. They need to issue the purchase order for it, and we get the licenses. Once the customer has the license, they can log into the UiPath Cloud portal, and it will be activated. Within five days, they can start using Document Understanding. After that, you need to build the automations for your use case. The development time frame depends on the use case. It requires maintenance because you must train the model continuously as new templates come in.

The price is high, so it will take you about a year and a half or two years before you break even. 

Document Understanding's pricing is reasonable for developed markets because manual entry will be unable to match the cost of automatically processing one page. However, you can get labor for much cheaper in developing markets like India. It's not easy to sell Document Understanding in markets where you can get workers who will do this type of activity cheaply.  

I rate UiPath Document Understanding seven out of ten. It's an add-on for UiPath, so it isn't a standalone solution. If you already have a license for another third-party solution for RPA, you should consider whether it's beneficial to switch. 

The primary use case revolves around processing invoices. In Israel, where the solution is region-oriented, the invoices typically involve multiple languages within a single document and may also include various currencies. The capability of handling such diverse linguistic and currency elements is a notable strength of UiPath Document Understanding in this context. Through its implementation, our goal was to minimize manual tasks significantly and reduce the time required for invoice processing.

Up to this point, Document Understanding has been applied primarily to automate invoice processing in our implementations. For the customers for whom we have implemented it, the emphasis has predominantly been on invoice processing. This is because, within the customer's value chain, these processes are perceived to deliver the most significant value.

In terms of the types and volumes of documents processed with Document Understanding, the volumes are measured per page rather than per invoice. We typically handle a range of 50,000 to 100,000 pages. It's important to note that invoices, which occasionally consist of more than two or three pages, are encompassed within these volume metrics.

Typically, the document format comprises a header, a table, and often a summary, along with occasional total figures. This basic structure is effectively handled by Document Understanding, excelling in processing both headers and tables seamlessly.

Approximately seventy to eighty percent of our customers' organizational documents undergo complete and automatic processing.

The benefits are straightforward– it eliminates the need for physical forms on the table. This simplicity instills a high level of confidence in the model, and I foresee a promising future for it. It stands out as an excellent solution for companies, particularly those dealing with a substantial volume of invoices and vendors from diverse sources.

It has liberated time for other projects. Previously, we needed three to four people for validating invoices. Now, we have scaled down to one part-time person, who, for the most part, is engaged in other responsibilities. Invoicing tasks occupy only around five percent of their work time, handled intermittently.

The most valuable aspect is the AI training model, which distinguishes itself by offering a more transparent and controllable approach compared to other products on the market. Unlike some alternatives, this model allows precise retraining of machine learning instances. It provides visibility into the training process, enabling control and the option to retrain multiple times as necessary. In contrast to comparable products, this transparency and control contribute to enhancing the precision of the training model.

Forms AI performs admirably, posing as a strong competitor to Microsoft's PowerApps and other similar products in the market. It is straightforward and versatile, yet there is room for enhancement in certain design features that could improve user experience.

Document Understanding seamlessly integrates with other systems and applications within the environment it operates. Its integration capabilities extend beyond RPA modules, ensuring smooth and trouble-free connections with various components.

Human validation is required for Document Understanding at the beginning of Document automation journey, constituting around thirty percent of the overall process, while the tool handles the remaining seventy percent and document straight through processing improver further with model retraining. Notably, the retraining feature is a crucial and valuable aspect of the platform. This feature allows for retraining based on the validation actions performed by human validators. This is particularly significant because it enables refinement of the model in cases where documents are validated with low confidence. Some of the platforms lack the capability to provide confidence levels for field and data recognition, making this retraining feature a valuable asset for businesses seeking precision and efficiency in document processing. The human validation process for each document typically takes only a couple of seconds. The validation requirements are easily identifiable, allowing you to point to the specific area. Typically, pointing to it triggers a quick refocus of recognition to a different part, making the validation process efficient and straightforward.

The average handle time before implementing Document Understanding was approximately between three to five minutes, but after automation, it has significantly reduced to less than a minute, possibly even just a couple of seconds. This improvement covers the entire process, including validation, data exchange, mailing approvals, and more, all seamlessly happening in the background. Beyond the time savings, the automation also substantially reduces rework caused by human errors, enhancing the overall efficiency and accuracy of the process. As per the customer, errors do occur at times, and the associated risk is considerably high. However, the implementation of Document Understanding effectively mitigates this risk, eliminating the potential for errors.

I wish to have more pre-trained modules available in various languages. For instance, while Document Understanding currently supports Hebrew for Israel, I would appreciate the addition of pre-trained modules specifically tailored for different Hebrew-related forms. This enhancement could prove to be quite beneficial.

I have been working with it for three months.

The system is highly stable, especially since it operates on the cloud. We haven't encountered any disruptions or issues.

When discussing Document Understanding and RPA processes, it's essential to highlight that it's a scalable solution on the cloud. The scalability it offers is truly exceptional, making it arguably the best in the market.

The technical support is outstanding. In Israel, we have a local UiPath office, and they are incredibly helpful. Their responsiveness is remarkable, and if there's ever a need for assistance, they promptly provide valuable support. I would rate it nine out of ten.

Positive

The initial setup falls in the middle ground – not overly complex but not entirely straightforward either. It requires an understanding of how to retrain the model and fine-tune both the OCR and the application.

Deployment time is a matter of minutes. The deployment process is straightforward as it involves a cloud solution. You order the environment, set up both the robotic and Document Understanding environments, and start working. It's a simple and quick process. Typically, the deployment involves one representative from our team and relevant subject matter experts from the customer's side. These experts are individuals directly engaged in the process, and often a reinsurance manager, functioning as a project manager, is crucial from the customer's side. It is imperative to have a subject matter expert from the customer's side because our team usually lacks visibility into their business processes and requirements.

Maintenance typically involves one person responsible for document validation. The specifics may vary based on the document type; for instance, if it's invoices, it's generally handled by a single person specializing in invoice processing. While I would assume similar patterns for other platforms, variations might occur with different document types, requiring different subject matter experts for each form. However, from the technical side, it usually entails the responsibility of one person.

In terms of Return on Investment, while we haven't quantified it precisely, the notable reduction in personnel from three or four full-time roles to one person handling the task part-time signifies a significant cost avoidance. Instead of letting people go, the approach involves reallocating them to other tasks, essentially avoiding around ninety-five percent of the previous budget dedicated to this particular process. The benefits in terms of cost-effectiveness and time efficiency are substantial. In the context of time to value, I'd estimate around two months to establish a production process, yielding impressive results ranging from seventy to eighty percent.

I think this timeframe needs to be considered with the multitude of invoices and vendors involved. We're dealing with processing invoices from over two thousand different vendors, spanning two different languages, including instances where both languages are mixed within a single invoice. The complexity is heightened by the inclusion of both right-to-left and left-to-right languages. Despite these intricate challenges, achieving the high complexity production process within two months is not only sufficient but also a commendable outcome.

For those interested, I would recommend undergoing a POC to truly experience and be pleasantly surprised by the outcomes within a couple of days. In an overall comparison with other solutions in the local market, I would confidently rate this as a robust nine out of ten.