RPA Expense Approver — From Manual Checking to Automated Approval

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

I built RPA Expense Approver, an automation project that helps process expense requests from a user-facing app.

The main idea is simple: instead of checking expense requests manually, the system allows users to submit a request through an app. The submitted data is stored in Google Sheets, then UiPath Orchestrator triggers an Unattended Robot to process the request automatically.

The robot checks the amount, updates the request status, and sends an email notification to the user.

The project uses:

• React / Expo for the request form UI
• Google Sheets as the request data source
• UiPath Studio for the automation workflow
• UiPath Orchestrator for process management and triggers
• UiPath Unattended Robot for automatic execution
• Gmail for sending approval or rejection emails

The automation flow is:

User submits request from app
→ Data is saved to Google Sheets
→ Request status is set to Pending
→ UiPath Orchestrator starts the robot
→ Robot checks the expense amount
→ Status is updated to Approved or Rejected
→ Email notification is sent to the user

This project means a lot to me because it helped me understand how frontend development and RPA automation can work together in a real-world workflow.

Demo

GitHub Repository: https://github.com/quochuy130725/ExpenseRpaApp

Demo Video: https://youtu.be/uE9z-dd6LQY

Screenshots included in the demo:

• Expense request form on the app
• Google Sheets receiving a new request
• UiPath Orchestrator job running successfully
• Gmail receiving the approval email

In the demo, a user submits an expense request from the app. The data appears in Google Sheets with the status Pending. After that, UiPath Orchestrator runs the ExpenseApprover_Process using an Unattended Robot. The robot checks the request and sends an approval email automatically.

The Comeback Story

Before finishing this project, the workflow was mostly manual. I already had the basic idea and some individual parts working, but they were not fully connected.

At first, the app could send data to Google Sheets, and the UiPath workflow could process the sheet manually from UiPath Studio. However, it was not a complete automation yet because I still had to start the robot myself.

During the finish-up process, I improved the project by:

• Connecting UiPath Assistant to Orchestrator as an Unattended Robot
• Publishing the UiPath project to Orchestrator
• Creating the ExpenseApprover_Process
• Configuring the machine, user, and folder permissions
• Testing the process from Orchestrator Jobs
• Setting up the trigger so the robot can run automatically
• Sending approval emails after processing
• Improving the data flow from app submission to Google Sheets and email notification

The hardest part was configuring UiPath Orchestrator correctly. I had to set up the machine, unattended robot, folder access, process, and trigger. After several failed attempts, I finally got the job to run successfully with:

Type: RPA (Unattended)
State: Successful
Source: Trigger

That was the moment the project became a real end-to-end automation system.

My Experience with GitHub Copilot

GitHub Copilot helped me speed up the development process, especially when working on the form submission logic.

I used Copilot to support tasks such as:

• Building the request form structure
• Preparing the submit function
• Formatting the data before sending it to Google Sheets
• Adding basic validation for fields like amount, category, description, and email
• Improving small JavaScript and JSON logic
• Writing cleaner and more readable code comments
• Drafting parts of the README documentation

One useful part was the form submit logic. Copilot helped suggest how to structure the submitted data so that each request could be saved with fields like:

ID
Amount
Category
Description
ImageBase64
Status
UserEmail

This made the data easier for the UiPath robot to read and process.

Copilot did not replace my work, but it helped me move faster. I still had to understand the project flow, fix errors, connect the services, and test the automation manually. It was most helpful when I already knew what I wanted to build but needed support writing or improving the code faster.

Final Result

By the end of the project, I successfully created an automated expense approval workflow:

Frontend App
→ Google Sheets
→ UiPath Orchestrator
→ Unattended Robot
→ Email Notification

This project helped me learn more about automation, system integration, UiPath Orchestrator, and how RPA can solve real workflow problems.

In the future, I want to improve this project by:

• Adding a backend API instead of writing directly to Google Sheets
• Using UiPath Queues for better scalability
• Adding authentication for users
• Creating a dashboard to track approval history
• Supporting more approval rules based on category and amount