UiPath IXP Reviews

We are a system integrator in the manufacturing industry and our clients use UiPath Document Understanding for their invoicing cycle processing.

Previously, our clients manually entered invoices into their systems, seeking a solution to automate this process while still maintaining controls for verification and audit purposes. We implemented UiPath Document Understanding to address this need.

Data entry is the most common use for UiPath Document Understanding.

In Italy, a common document format for simplified sales invoices is the BBT, which lists the total cost of the entire merchandise unit.

Since our clients are primarily small and medium-sized businesses, UiPath Document Understanding processes around 10,000 documents annually.

The documents contain a header and a large table where data is extracted.

Around 30 percent of the documents are fully completed by UiPath Document Understanding.

AI and machine learning do a great job sorting and identifying fields and documentation orientation. Managing different layouts is the most valuable attribute of AI.

Companies that use the UiPath platform can easily integrate UiPath Document Understanding using a few modules.

Human validation is required for 20 to 30 percent of cases and it takes less than one minute to complete.

UiPath Document Understanding helps reduce human error by 70 percent.

UiPath Document Understanding has helped free up around 70 percent of people's time to work on other projects.

For most of our clients, the time to value is usually six months.

The prebuilt algorithm for extracting foreign invoices is the most valuable feature because it eliminates the need for us to build anything from scratch.

The signature and handwriting are a pain point for the OCR and have room for improvement.

The extraction logic portion of the UI is not as user-friendly as the rest of the platform and has room for improvement.

I would like to have generative AI integration added to a future release.

I have been using UiPath Document Understanding for two years.

The stability of UiPath Document Understanding is good. The higher the stability the less maintenance is required.

The scalability can be improved with the help of generative AI. It is difficult to build an algorithm and move to another project without making important changes to it.

The technical support is good.

The initial deployment process is not user-friendly. It requires a lot of steps, although depending on the size of the deployment, one person can usually manage it.

The average deployment takes around one month to complete. 

We implement the solution for our clients.

The price for UiPath Document Understanding is a bit expensive.

I would rate UiPath Document Understanding a nine out of ten.

The number of people required for maintenance depends on the project. It can go from one person up to seven.

I use the solution in different ways. There are different ways to deal with the documents and extract data using OCRs, et cetera. I focus on document understanding with machine learning capabilities baked into it. 

I have worked on different types of documents. Both structured and unstructured documents as well as purchase orders, invoices, and time sheets as well. Depending on the type of the document or form, the solution would be different. If we have a structured document to retrieve the known information, then that would be easy. We would just use regular methods and simple extraction methods to get the data. However, if the documents are unstructured and the formats of those documents are different, that's where we would be using understanding and machine learning capabilities.

I've used it in healthcare, finance, and investments.

We're dealing with multiple vendors right now. When we deal with multiple vendors, each vendor has different structures for documents, and some of them provide data within papers while some of them provide just data as paragraphs. So for each of those types of documents, we have to extend the data based on the need.

How much the process is automated depends on the use case. It depends on the scenarios of the different types of formats of users. Sometimes there are different functionalities that we have to use within UiPath. If we're using Action Center, we probably would be able to automate almost all documents and that's where we would need users' input to validate the right information. In any case, we would be able to automate the majority of the documents since the bot would be able to expand the data. In such cases, the process might be longer. That's where we have to spend more time. However, if the documents are structured, it would be very easy for us to identify the data in those documents and then build the workflows.

The ability of UiPath to handle variant document formats, including handwriting is decent. Extracting the data is fine. However, it depends on what solution you implement and how much time you are ready to spend to implement that solution. If we have a plan to involve the Action Center within the solution, then that's where we would need a few inputs from the users to make sure that the automation is working fine, and that's where you would be able to achieve the majority of the success rate. However, if it is something that we just want to automate and we don't want to involve humans in it, then that's where we might result in a few exceptions as the data might not be right. That's where we would face some challenges. 

The machine learning capabilities have been quite fine. We've been able to digitize and classify documents and use them in our processes. That said, when compared to AI fabric, that's where we need to spend more time creating our own packages for it and then deploying those packages into the workflows. We need to make sure that we have a handle on all the documents.

I have found that 70% to 80% human validation is needed if we are trying to deal with sensitive data or if we are trying to deal with some confidential data. In those cases, we need to make sure that all the data is right. So as long as the document is structured and is well defined, and well-formatted, we might leave it 100% to automation. If any of these details are confidential or if any of these details require evaluation, then we will need user interaction. 

The validation process can be pretty quick. A code document doesn't take much time. It depends on the data. In any use case, I need to extract more than ten or 12 fields. If we're dealing with that number of fields, I'd estimate we need between two to 22 minutes.

The Average Handle Time, the AHT, depends on the cases. If there's no human involvement, then it would definitely take less time. If there's human involvement, the product could at least reduce the effort. The human involvement may drop from 20 to 30 steps down to one and they are just needed for validation. That scenario shows UiPath as a great time saver. Initially, we used to take 15 to 20 minutes to work on a document. Now, with automation, it might only take two to three minutes. It saves 65% to 75% in terms of time. 

There's still a chance of human error or tasks taking a few minutes as users would need to input some data into the document in the Action Center. That said, there is definitely a reduction and less of a chance of human errors over there. 

It's helped us free up time for other staff projects. That's the intention of implementing automation. Users can reduce their time on tedious tasks and focus on more important business needs. 

Document understanding works fine, however, it depends on what information you are providing it with. If the data is right, the data is good, however, in cases where the data is not right, it gets a bit difficult.

They could work on the digitizing and classification of documents. That would play a major role in document understanding since that's where we need to make sure that bots are able to extract data from multiple formats or multiple structures of the documents. The better they get at data extraction, the better we can automate. 

I've used the solution for two and a half years. 

I have worked on different use cases. There was one use case where I just worked on a similar type of document that had data entries for more than 300 to 400 users. I have worked with more than 400 to 500 documents of different formats and different sources. That's where I had to use machine learning packages. Right now, we are working on documents, with set formats and different structures, however, the volume of the documents is about 400 to 500.

They have a good technical team that supports the needs of the developers. 

Positive

It could actually take one year if you consider the effort which we had put into building that solution as well. We have a few developers working on it. We wouldn't see a return on investment within eight to ten months as we would just be starting with building the processes. 

We have witnessed some ROI. For example, it reduces review work from 60% to 70%. That's where the full-time employees would definitely save their time and can then focus on much more important business needs, which could help them get more projects or increase revenue as well. That's where you would see the most ROI. 

It definitely reduces the hours of work. The bots have the potential to also cover offline hours. 

While it depends on the use cases, the document understanding is good. I'd rate it eight out of ten.

The product is very, very nice. The tool relieves the data entry team from manipulating data. It shortens the time of extracting data by 70 to 80%.

UiPath should localize the built-in features for supporting Arabic scripts so we do not rely on third-party tools. It will take some investment. Sometimes, when we use third-party tools, we need to collect multiple samples of the same document in Arabic. It creates some errors in understanding. 

Sometimes, we need to do multiple formats for the same document. It happens due to the nature of the Arabic language. For the same document in English, we only supply one template. The output of handwritten documents in Arabic is very poor, regardless of the solution. For computer-printed documents, we need to tune the system.

I am using the solution currently.

The product is stable.

The tool is scalable.

We were using our own intelligent business processing solution. It is more convenient to use because it's our own product, and we rely on Amazon Web Services. It provides big advantages for Arabic scripts. It is more understandable.

The product is easy to implement to an extent. If we are familiar with the input, processing, output, and how to declare variables, it's easy. If we are new to UiPath, it would be somewhat difficult to understand. UiPath Academy and certifications are very important.

The difficulties in implementation depend on the environments, document sources, document types, and customer understanding. Sometimes, customers think the product can pass anything without configuration, which is not true in some cases. We have to be very clear with the customer about the type of documents and layout they can expect. Two working days are sufficient for configuring, extracting, and linking the process. One person is enough to deploy the solution.

The pricing depends on the context of the project. UiPath is a pricey tool for small customers. If the customer agrees on the cloud product, we discuss the cost accordingly. In some cases, even though the customer sees value in the product, return on investment, productivity, and enhancements of their processes, they decide not to choose UiPath due to budget constraints. They choose a different vendor.

Sometimes, the customer is small, but we could see the potential for using the tool because they might have multiple processes. The price we offer is based on the context and the size of the opportunity we get for references. Document Understanding has helped us automate processes like contract management, reconciliation of invoices against purchase orders, claims management, and HR processes.

We process 100,000 to 500,000 documents in a year. We also had a project for Dubai Customs to reconcile the customs clearance, which involved 500,000 to 1,000,000 documents. These documents contain tables, bar codes, dates, and checkboxes. Tables might span over multiple pages, and we must capture it completely. It becomes challenging sometimes. If there is an invoice of three pages, everything must be captured, but sometimes the values are inaccurate.

Around 70% of our organization’s documents are completely processed automatically. We haven't used the product for signatures. Customers often see from a productivity point of view. If their employees process ten documents an hour, and the tool processes 50 documents an hour, using the tool is an advantage for them.

The tool does not work for integrations. It extracts data. When we extract data successfully, we rely on other business tools for integration. Document Understanding serves as a first milestone in the process. The tool at the second milestone would pick up the extracted data and post it according to the processes or applications used.

We need human validation of Document Understanding outputs three out of ten times. It does not take more than 20 to 30 seconds per document. An employee would take ten documents per minute. RPA could handle 30 to 40 documents per minute. Document Understanding has helped us reduce human errors by 70% to 80%.

Document Understanding has helped free up staff’s time for other projects. From a development point of view, it has freed up 70% of staff's time. From an employee's point of view, it has freed up 80 to 90% of their time. We saw the value of the product after a couple of projects, especially when we implemented it and saw the value for ourselves. As a customer, vendor, or implementer, when we see the execution, we see the value.

If someone wants to take advantage of this technology, they must think multiple times about different scenarios. They must centralize the capture or the source of data. They can use any product that is easy to use and configure and link it to the processes. They must sync the templates and the configuration multiple times and link it to the automation strategy.

Overall, I rate the solution a five out of ten.

We use UiPath to automate invoice generation in our manufacturing process. One large project I worked on was for electricity bill payments. This project involved document processing, and I gained some experience with document processing and process mining. From there, we started using UiPath Document Understanding for the bulk of invoices we were receiving. We then had to put those invoices into the document processing model because they had a uniform structure, but there were also some handwritten notes and values in different places. So, we had to opt for document processing. Right now, we are developing a proof of concept for one of our government websites. This involves tender documents. We download and process the tender documents, extracting data such as the quotation, validity period, and other details, and putting it into a database.

We are processing documents in the hundreds using UiPath Document Understanding.

The standard document contains header information such as the company name, quoted value, quotation price, and expiration date. There are also tabular details regarding the items to be delivered. The tabular structure has headers, but checkboxes are not present in this particular use case. In addition to the header and tabular details, the document may also contain handwritten notes.

We have deployed UiPath Document Understanding on-premises but given the choice we always recommend the cloud because it includes more features.

UiPath Document Understanding eliminated the manual process of extracting data from 50 different websites each day.

Our customers' documents vary by website, but their structure is fairly uniform. As a result, we were able to process approximately 70-75 percent of the documents automatically with very good accuracy.

UiPath Document Understanding can identify and export signatures and handwriting from clear documents, using machine learning.

AI and machine learning feed the unprocessed raw data to some of the custom machine learning models. I have been working as a backend developer, so I have experience with machine learning as well. I tried with some of my own models, and it was clear that the customization of these models to our specific data requirements is very impressive.

UiPath Document Understanding's ability to integrate with all the systems and applications in our environment depends on the specific requirements of our use case. If it is generating a good return on investment, then I will consider using it for document processing. However, if my requirements can be met without using document processing, I will definitely choose to use simple OCR techniques instead. Traditional OCR engines can extract data from documents and place it into databases, where it can then be manipulated. However, this approach can be time-consuming and error-prone.

UiPath Document Understanding has helped our organization improve. It is especially useful when there is ambiguity in documents, which is a common real-life scenario. Inbuilt OCR engines are often unable to perform data inspection accurately in such cases. Whenever we have a large volume of documents to process and need to ensure high accuracy, UiPath Document Understanding is our first choice. One of the key benefits of UiPath Document Understanding is that it provides a dedicated model for document processing. This means that developers do not need to worry about other details and can focus solely on the task at hand. Additionally, UiPath Document Understanding integrates seamlessly with machine learning and AI models, which further enhances its capabilities.

Some of our customers were reluctant to switch over, and for a long time, they did everything manually, so their documentation was very outdated. As a result, we were required to manually validate 30 percent of the documents. The time to manually validate depends on each document. If two or three fields are mismatched, it does not take much time to correct them. However, if the entire document is showing errors, that will add time to the manual validation process.

It reduces the risk of human error and the time we spend processing documentation, freeing up our staff to work on other projects.

OCR technology is undoubtedly the most valuable feature and the feasibility of integrating data processes with AI and machine learning models is fascinating.

The identification and extraction of signatures is the most difficult part of the process, and there is room for improvement.

The machine learning model needs improvement, as we receive more and more unstructured documents from clients that require a lot of manual validation.

I have been using UiPath Document Understanding for three years.

UiPath Document Understanding is stable.

UiPath Document Understanding is scalable.

I've seen many clients refuse to purchase the licensing when they see the pricing. They're quite impressed with the results, as the bot does so much work in less time with accuracy. However, when it comes to pricing, I've seen clients refuse to spend that much on the licensing cost for UiPath Document Understanding.

On a scale of one to ten with ten being the most expensive, I rate UiPath Document Understanding an eight on cost.

I would rate UiPath Document Understanding eight out of ten.

I definitely recommend UiPath Document Understanding to anyone who is trying to do any kind of document automation. In fact, I have some friends who are working on an RPA project using UiPath, and we have been discussing it. I recommended Document Understanding when it first came out, and I think they have been using it for the project.

We have processes for purchase orders. We need to analyze the content of these files and some invoices. Based on that, we are able to perform qualifications and post them to the CRM system. Overall, we call this our invoice control process.

We wanted to optimize the performance, meaning the time the process takes, and the quality. We had some problems with the quality of transferring the data because people would make mistakes. If they were doing 80 documents per day, there was a high possibility that they would forget to look for some information or they would copy and paste the wrong fields.

The main benefit for us has definitely been a faster process. We have sped up the process of analyzing the data. A second one is the improvement in the quality of our implementation.

In our organization, we are now at 30 percent of our documents being completely processed automatically. And in terms of human validation required for output from Document Understanding, we need it for 15 percent of the cases. We have decreased the time needed for such processing by 70 percent. And regarding human error, we have seen a decrease of about 60 percent.

One of the most valuable features is the intelligent recognition of the fields. The algorithm is able to recognize them based on the pattern. Also, the machine learning model enables you to use predefined solutions. The machine-learning capabilities of the solution are very cool. I really like that part, and I hope it will be developed even more in the future. I'm really excited to see how it will develop.

Integrating Document Understanding with other systems and applications is very easy if you already have some background. It just requires some mature developers to do so, and we are just about at that stage. It's very user-friendly, but the documentation could be a little more detailed. Besides that, it is fine.

With handwriting, we had a problem. It wasn't able to extract it because we have handwritten documents in Polish, and that language is not supported at this time.

Also, the documentation should be more clear, or better training should be provided.

We have been working with UiPath Document Understanding for about eight months.

Scalability is very easy to manage. It's very natural. The only thing that changes is the number of processes and the number of licenses. The more money we save with it, the bigger we will scale it.

We are using it across four departments.

I really like their customer support. They are very responsive.

Positive

We had ABBYY. The advantage we see with UiPath is that it's easier to implement things with RPA. Some of our teams are still using ABBYY, but our team has declined to use it anymore for automation.

I'm the system owner and architect, so it was on me to set it up. The initial setup was very complex in the sense that we had to play with the firewalls and other things to make it work.

It included the entire cloud, not only Document Understanding. It was very tricky to do it the correct way. We had to do a lift-and-shift. We updated the on-prem environment to the latest possible version and then copied the entire base to the cloud. Later, we upgraded each process, and, once the process was upgraded and ready to work in the cloud, we moved it to the target tenant.

At this moment, it does not require any maintenance.

We did it ourselves. We had a team of 20 people, but that's because we have a lot of processes.

We will need to have the solution for at least one year to have a clear view of ROI. It's the same for time-to-value with the solution.

It's expensive, but you can reduce the price per license by getting more licenses. Overall, the pricing is okay.

One area for improvement would be a different licensing model. Right now, we have to assign a license to allow a user to do validation. We think that standard access to Orchestrator should allow a user to validate.

Definitely talk first with a UiPath representative to get someone who will take care of you and the implementation. Do not waste your time reading through the documentation because it's very messy.

Our client has PDF invoices and we use the solution to extract the details from them. We are using it in finance and health care. We have about 16 templates that we process now. The data is in semi-structured format and we mostly process things like signatures and tables. Out of the 16 templates, about 12 are completely processed automatically.

It has helped us automate finance statements and invoice billings.

Another benefit is that it has mostly helped reduce human error. We have a criteria of 75 percent matching. Out of 10 PDFs we have been getting eight PDFs with at least 75 percent matches. It has also helped free up staff time.

The taxonomy and Validation Station are among the most helpful features for us. If anything is extracted incorrectly, we can manually extract it there.

And we have included the AI Center for our customers to interact with PDFs to be extracted. Based on the approval or rejection feature, our customer can determine which kinds of PDFs they can automate.

I also like the table extraction feature. UiPath is very good with structured data.

Handwriting is more complex. We have not been able to get handwritten signatures correctly extracted in different languages. Our customer is in Dubai, and the solution cannot accurately process signatures in the local language. But it is a great tool for handling structured and semi-structured formats.

Another of the disadvantages is that we cannot include another tool. For example, with ABBYY extraction, we can integrate the process with any other product. We can integrate Document Understanding using JSON templates, but it is a bit of a complex model to extract the data from the JSON.

There is also room for improvement in long-running table extraction. If a table continues for more than 10 pages, in some cases, we have observed that it only extracts six or seven pages and skips the last pages.

I have been using UiPath for about 10 years.

Overall, the product is stable.

In our case, the use of Document Understanding is restricted to a particular group of users, around six or seven people.

The technical support from UiPath has been pretty good in the last year. It has been a very good experience. 

We used Azure DevOps for the deployment and we faced some issues regarding the deployment with UiPath and Orchestrator. We had a very good response from the UiPath technical team.

There is some room for them to improve the speed of the response because we often used to get late responses. But the resolutions are good.

Positive

We were using ABBYY, but it is more like a developer's tool with everything a developer needs for extracting fields. But we can train and retrain Document Understanding. In that way, I feel it's a better tool.

The pricing is reasonable.

As for additional costs, the solution is based on OCR, and sometimes the OCR cap is exceeded. It's not a major cost. Per month, we will have two or three scenarios like that. With ABBYY, once the cap was reached, we had to wait until the next day to use it again.

We did not evaluate other solutions. Using Document Understanding was a requirement from the client's side.

In terms of human validation for Document Understanding output, we have a limit of 75 percent correct scenarios. If it is below 75 percent, the user will be notified.

The solution doesn't require any maintenance unless the client requires more fields to be extracted. Only then are there changes that I need to make.

My advice is that if you are starting to learn about Document Understanding, you need to learn more about the taxonomy and what fields you are extracting. You need to have clarity on which position you are extracting, as it mostly depends on the position.

Our primary use cases for UiPath Document Understanding are processing invoices for five different clients and importing/exporting documents to extract vital information, mainly from unstructured documents. These five clients are from various industries, including transportation, scientific research, food services, and clothing.

I processed 400 documents per day for one client and 20 documents per day for the second client.

The documents processed were in PDF format.

90 percent of the 400 documents processed per day for a single client were fully automated. However, only 50 percent of the 20 documents per day were automated due to their greater level of unstructured nature. As a result, the remaining 50 percent had to be sent to the action center.

AI and machine learning for Document Understanding are game changers. Machine learning was helpful in identifying the various areas of the documents from which I needed to extract different types of information, making the process quicker.

The default model didn't work for me because I needed to extract information from documents written in French. Thus, I had to create my own model using AI, which proved to be exceptionally beneficial for handling the French text and its accents.

Integrating UiPath Document Understanding with other systems and applications in our environment works well. The solution was able to retrieve the PDF document from an email, extract the details using the command, and apply those details to an application, saving a substantial amount of time.

UiPath Document Understanding serves as a safeguard in relation to cost and time savings, as it diminishes the manual workload for employees and minimizes errors. For a job that took a human eight hours to complete, the bot was able to do it in three hours.

The extent of human validation needed for Document Understanding varies for each client. For one client, no validation was necessary as the solution effectively extracted all required information from the documents. However, for another client dealing with diverse document types, errors occasionally occurred due to character placement. This was particularly evident when email addresses were positioned differently, some at the top and others at the bottom of the documents, posing challenges to the robot's detection capabilities. In such instances, a validation process was implemented. Every seven days, ten percent of the batch would be sent to the Action Center for validation.

The time saved with UiPath Document Understanding is exemplified by an organization that previously had to spend three days manually extracting information from 400 documents every month. However, with UiPath Document Understanding, this task now only takes two hours.  

Machine learning is the most valuable feature of UiPath Document Understanding.

I encountered difficulties with UiPath Document Understanding in determining the appropriate OCR to use for certain files. These files required extracting both the company logo from the page and the digitized text, posing a challenge. The OCR engine faces difficulties when processing signatures and scanned documents with unclear handwritten text.

The robot faces difficulties in recognizing when there are multiple documents on a single page. This necessitates manual intervention by first splitting the document and then re-digitizing each part separately. 

I would like a split feature in a future release of UiPath Document Understanding.

I have been using UiPath Document Understanding for one month.

UiPath Document Understanding is extremely stable.

UiPath Document Understanding is scalable.

The technical support responds promptly and strives to resolve our issues quickly. However, there is room for improvement. For instance, we encountered an issue with the Action Center, and the support team was unable to determine the cause for three days. Eventually, someone from my team resolved the issue.

Neutral

The initial setup was a bit complex.

I also assessed FlexiCapture, but I discovered that UiPath Document Understanding was more user-friendly. Coming from a scientific background, I found that UiPath Document Understanding offered a more logical and less complex solution.

I would rate UiPath Document Understanding nine out of ten.

It took me one week to study UiPath Document Understanding and to present it to my organization.

I realized the benefits of UiPath Document Understanding once I completed my first project.

The quantity of personnel needed to maintain the solution relies on each project. In the most recent project I participated in, we needed a total of two individuals, one of whom was an administrator from our team.

When using UiPath Document Understanding, always ensure that the number of structures is the same each time to prevent errors.

I believe that utilizing communication mining would be more effective with the AI Center.

We implemented UiPath Document Understanding for our first project with a pharmaceutical insurance company. They were receiving invoices from over 2,000 different vendors in a variety of formats on a daily basis, and they wanted to automate the process. We are receiving invoices in their email, and we are automating the download and processing of these invoices. If the confidence level of the automated data extraction is low, a user or client can correct the data according to the invoice and then submit it. The data will then be improved. We will be automating this project in two parts: first, reading specific emails and downloading the attachments; and second, checking if the attachments are normal documents or invoices.

We have implemented UiPath Document Understanding for two companies: one in the insurance industry and the other in the financial industry. We have completed the document creation process, which includes OCR and automatic signature imposition by different lawyers on the finalized documentation. We also use Document Understanding to read the document after analyzing it, and we then update the PDF with a front page signature and other components. This is a small process, but the first project was very large and we gained a lot of business from it. It was a very good project overall.

We process between 100 to 200 documents per day using Document Understanding.

The documents include checkboxes and barcodes. Some of our vendors only provide handwritten invoices, which Document Understanding could not read. These invoices had to be processed manually by the user.

UiPath Document Understanding can handle varying document formats including handwritten documents.

We have implemented a machine learning model to sort vendor names and important information related to those vendors into our system. When the model encounters a vendor that it has already seen, it automatically grabs the important information from the invoice. The model is continuously training on the new data that it receives, so it can become more accurate over time.

Machine learning was very good. We don't think we can implement without any ML model.

We integrated Document Understanding with Dynamic CRM so that the information extracted by Document Understanding is automatically input into CRM.

The amount of human validation required is based on the confidence level of the ML model. Each time human validation is required, the ML model learns and the need for human validation decreases. At the start, the ratio of documents requiring human validation was 50/50, but this ratio decreased with each iteration.

Document understanding helps reduce human errors. For example, if we receive 150 emails daily, we must analyze and process each email accordingly, such as sending invoices, checking invoice values, and investigating all relevant information. We must then read each invoice and enter the data into the system. This is a very active task that requires around 15 people to perform daily. Document understanding has reduced the need for human interaction by allowing us to automate this process. Now, only one person needs to analyze the email invoices. Once the invoices have been checked and analyzed, they are passed to a UiPath bot, which handles all the subsequent steps, such as reading the invoices and entering the data into the system.

Document understanding has helped free up staff time.

UiPath provides a useful feature that allows us to classify documents as invoices or not.

If the confidence level is low, we can check it and provide the product value to move forward. In this step, the user can sometimes skip or delete pages, especially if we receive a large PDF with the first two pages being invoices, followed by some relevant documents, and then more invoices in the same period. This is a very good feature of UiPath Document Understanding, as it allows the user to skip pages within the PDF document to move forward. For example, the user can specify that the first two pages and pages nine and ten are invoices.

UiPath Document Understanding's ability to read handwritten files has room for improvement.

The price of Document understanding is high, and we are constantly struggling to get our clients to use it because they find it to be expensive.

I have been using UiPath Document Understanding for one and a half years.

UiPath Document Understanding is stable. We have not encountered any downtime.

UiPath Document Understanding is scalable.

The technical support was helpful.

Positive

The initial deployment was straightforward.

Two people were required for deployment.

The implementation was completed in-house. We have a large team that includes technical consultants, architects, and developers.

The last time we implemented UiPath Document Understanding the price was high.

I would rate UiPath Document Understanding six out of ten.

I've done multiple projects. A couple of them included invoice processing. It has a machine learning package that works out of the box. For invoices. I use that. It does a very good job. 

I also use document understanding, which doesn't have any training. I trained it for the extraction of data for some forms like car loan installments. It did a pretty good job. 

In addition, I used it for a medical department. I use document understanding. 

We wanted to have a way to do data extraction from PDF documents. It helped us automate the process. For example, if you purchase a car, the loan installment paper includes items like the vehicle number, purchase information, buyer and seller information, et cetera. It can pull that out. We can also use it similarly in the healthcare industry, to get client details. 

It's great for document understanding for invoices and installments. 

When it comes to document understanding for handwriting, it does a decent job sometimes with handwriting, however, some people have weird handwriting and the OCR can struggle to pick up the information. In those cases, you have to read it yourself. However, overall, it does a decent job. I haven't used it to read checkboxes or bar codes. It works well with tables, however.

There are thousands of documents that are completely, automatically processed. It can process close to a few thousand invoices per day.

I also integrated it with the Action Center for some projects; It's pretty neat.

I like the machine learning skills and the fact that they come out of the box. They are packages that you can just deploy. The training of the ML is great; there is this tool that comes with it called Data Manager. That's very handy when you are labeling data and then using it. 

The AI center is excellent. AI does a pretty good job covering all the needs that are needed for automating the process for semi-structured documents. The structured documents with the form extracted, overall, are pretty good. It's doing a very impressive job. I was surprised the first time I was exposed to it. Now, I actually enjoyed doing it. It allows me to automate items that are mundane. For example, if an employee is given a task to scrape data from invoices, which are PDFs, they can get the robot to do it. Due to the fact that the documents most of the time are semi-structured, machine learning can handle the task, and machine learning is doing a pretty good job of handling that instead of the employee.

I've used Forms AI. So far, my experience has been pretty good. That said, it only works for structured documents. 

In terms of the documented understanding of integrating with other systems or applications, everything is good. You can integrate it with the action center, and it does a very good job. Everything is handy and easy to use. Integration overall is good.

Human validation is not always required for the outputs. It depends on the document. For invoices, you might need human validation 5% to 10% of the time. If it processes ten documents, I would expect one document at least to need human intervention. If you are building some custom ML skills for some documents, if the document itself is scanned well and positioned well, it does a pretty good job of extracting the needed fields. If it's slightly less quality then the robot will struggle with both the OCR or extracting and digitizing data. Overall, we might need 10% to 20% human validation. The validation process itself now takes about a minute with the help of automation. It's reduced everything by a minute or two to up to five or six minutes. 

Document understanding has helped us to reduce human error by at least half.

The only problem that I can see with integration is some of the features cannot be used inside the loop. At least that was the case before. I don't know if they fixed it or not. You can't put some of the activities that are de-related inside the loop. It's going to throw an error if you do.

It would be ideal if they could include more packages for more use cases.

I've used the solution for about a year. 

I've contacted technical support and they have been helpful. 

Positive

I'm a customer and end user. I work as a developer. 

I'd rate the solution nine out of ten overall. 

UiPath can handle normal, structured documents like forms and editable PDFs, but the data cannot be extracted from some unstructured documents with normal instructions. Non-standard documents are the most challenging thing for us. For example, let's say you have a hard copy of a receipt you get from a store, and you want to keep a record of it. You need to extract specific types of data and store it in Excel.  Document Understanding can deal with these documents. You can configure it to scan the receipt and identify the data we're interested in. 

We can provide a set of optimizations, classifications, and preconfigurations before we process the document. We created a taxonomy that we've predefined that these kinds of documents can conform to our security purposes. Using the taxonomy, Document Understanding can first classify the type of document, the arguments or variables we want to use, and the data we need to extract or store. Document Understanding can scan a written document and identify if a signature is present. 

We keep a person in the loop in between because we can't 100 percent rely on the extraction. Document Understanding uses OCR which sometimes struggles with handwritten material. For example, it might mistake a six for a five. There must be a human in the loop to ensure quality. The device will send it to the validation station on your mobile phone. The bot will learn from the choices you make, and it will be more accurate the next time.

Document Understanding helps us to reduce human error. It can reduce the time staff spends on some tasks, but the amount of time saved depends on a few factors. We still need to validate the data because before proceeding, we sometimes collect and share sensitive data for our clients. We need a validation step in between to check before we send any data. 

One benefit of Document Understanding is machine learning. As we process more data, we train Document Understanding to classify information more accurately. Document Understanding can extract and interpret information similar to the way a human can. A human can read a paragraph and distinguish between types of information, but our UiPath bots can't. Document Understanding integrates with artificial intelligence to interpret information within that. 

The newer versions of Document Understanding can integrate with ChatGPT or any generative AI tools so that it can better interpret the information autonomously, and we don't need to create the taxonomy or classify the documents. We only need to give a prompt and input the document. 

It will read documents similar to the way a human would. Let's use a contract as an example. You want to extract data like the buyer, seller, property address, etc. It will take the information from the document and give it to you. It can also scan for checkboxes and identify which ones are checked, but there are some limitations. 

It uses a document object model to map which data is on what page of the document. For example, let's say the data you are interested in is on the third page of the document. The model knows where the data is, so it directly jumps to that particular page and extracts the information. The mapping is very perfect. 

We always use attended processes because it's a good practice. The bot can do it without a human in the loop, but I would only do that if you are certain about which information you want to extract. If you're working with a handwritten document or signatures, you need a human in the loop to validate the data and help the machine learning component learn the difference between correct and incorrect information. 

The time required for the validation process varies depending on the number of fields. For a small number, it only takes two or three minutes. When you have more fields, it may take a little longer to create and configure the document understanding model. You need to create the taxonomy, classifications, and model.

The validation process is easy. The Validation Station shows you the extracted data on one side and the document on the other, so you can easily scroll down and check if the data is accurate. You just need to click a checkbox. If you don't think it is fine, you have the option to add an exception. Based on that exception, you can create multiple conditions for how to address the same issue if it happens again. 

Document Understanding is about 75-100 percent accurate depending on the type of document, and it increases as you train the model. 

I would like to see more integration of artificial intelligence. That's being implemented, but it would be a massive improvement to the solution's document processing. If UiPath achieves intelligent document processing, it will be far better than anything on the market. There are currently some limitations with the fields that could be addressed using a GPT engine. With an integrated AI model, you wouldn't need to create your taxonomy. You would only need to provide some prompts, such as "What is the property name?" It will store that as a variable.

I started using Document Understanding six months ago. 

In the community version, there is a limit on data extraction using a form-based extractor. There are limitations on digitization in the community version. You can do only 50 or so in one hour. The enterprise version can handle a larger volume of data, but we aren't dealing with huge amounts of data. We can still use multiple types. It allows you to scale with multiple types of extractors in the same document. If I'm confident in how the model is processing a particular field, it can be adopted into the regular business structure and reused. 

I was involved in the deployment only as a developer. We created the taxonomy and the model for Document Understanding, then tested multiple cases with multiple documents. We see which extractor would be the best fit for a particular value. We can classify it according to the values we want and we can set up an accuracy also. We can set a confidence level for each variable, so the confidence is different for a regular extractor versus a complex one. I set the confidence level high on the regular extractor. 

Initially, the deployment is somewhat complicated for a developer. However, it gets easier once you understand everything. We didn't need a consultant. I could complete the job by myself. It isn't rocket science. UiPath Academy has a free course on Document Understanding. Anyone can use it for free. 

We use the free community version. Anybody can use it, but it has some subtle limitations. The enterprise license gives you far better results without limitations.

Document Understanding can handle handwriting and signatures in most cases. The community version limits handwritten document processing, but it's enough for our needs and gives us the correct data every time. 

I haven't worked with any other document processing solution besides UiPath. I researched some tools, but Document Understanding seemed like the best fit for me, so I used it.

I rate UiPath eight out of 10. I deduct two points because creating the configurations can be time-consuming.