Inspiration
This was my first hackathon, and I wanted to build something that was both technically meaningful and close to real enterprise automation problems.
The original inspiration came from a simple observation: many companies still depend on old ERP systems. These systems may not have clean APIs, and a lot of business logic is hidden inside old screens, manual approvals, exception handling habits, and undocumented workflows. Replacing them directly is risky, but keeping everything as fragile RPA scripts is also not enough.
So I wanted to explore a safer modernization path: let UiPath operate the legacy UI first, let agents observe and reason over real business cases, record evidence from each run, and only promote repeatable and validated actions into reusable workflows or API-mode automation.
What it does
Agentic ERP Modernization Layer demonstrates a governed automation loop for purchase order exceptions in a legacy ERP scenario.
UiPath reads ERP work items through browser automation, extracts purchase order fields, and sends the case information to a reasoning agent. The agent returns a structured decision object, including the exception type, risk level, recommended route, evidence, and next stage.
For the main demo case, PO-1001 is classified as budget_exceeded. UiPath routes it to human approval, waits for the manager decision, writes the approved status back to the legacy ERP UI through RPA, then calls a validation service and a generated API candidate. After validation, the same business action can be executed in API mode.
The project also includes an Automation Memory Layer. Each run records case timeline, agent decision, human approval, RPA trace, validation result, capability registry, and capability gaps. This is important because the project is not only about finishing one automation run. It is about showing how repeated ERP cases can gradually become trusted reusable capabilities.
How I built it
I built the project with UiPath Studio, a mock legacy ERP web app, a reasoning agent service, validation services, generated API endpoints, dashboards, proposal pages, and structured memory records.
UiPath is the orchestration and governance layer. It opens the ERP work queue, reads real screen fields, calls backend services through HTTP requests, routes cases through a Flowchart, handles human approval, writes back to the ERP UI, and calls the validated API mode.
The backend simulates the enterprise modernization layer. It provides exception triage, policy and validation checks, run memory, proposal generation, capability gap detection, and demo dashboards.
I also used coding agents during implementation to help generate and refactor backend services, API candidates, documentation, and demo support files. However, I did not let the coding agent automatically deploy or approve new capabilities. New workflows or APIs are treated as candidates and must go through validation and human approval before they can be trusted.
Challenges
The biggest challenge was that I was learning many things at the same time.
This was my first hackathon, and I had to understand the rules, the submission requirements, the UiPath ecosystem, and the expected judging focus while also building the actual project. The language barrier also made the process harder, because I needed to read English requirements carefully and make sure I did not misunderstand what should be submitted.
Another challenge was time management. At first, I focused mainly on getting the local UiPath + ERP + agent workflow working. Later, I realized that cloud readiness and deployment evidence should have been planned earlier. Because the deadline was close, I did not want to pretend that a full cloud version was already implemented. Instead, I added a cloud modernization plan document to explain how the current local architecture can be extended to cloud deployment, Orchestrator assets, queues, and stronger governance.
Technically, the hardest part was making the demo feel like a real modernization workflow instead of a scripted animation. I had to deal with UiPath selectors, browser automation stability, local service ports, slow or unavailable LLM calls, approval flow design, and how to make memory, validation, and capability evolution visible to judges in a short demo.
What I learned
I learned that enterprise automation is not just about making a robot click faster.
A strong modernization story is about governance, evidence, approval, validation, and gradual trust. RPA is valuable because it can operate legacy systems today, but its longer-term value is even greater when it helps reveal the real business workflow and creates evidence for future API or workflow modernization.
I also learned that agents should not freely execute high-risk enterprise actions. In this project, the agent gives structured recommendations, but UiPath controls the workflow, human approval controls risky decisions, and validation controls whether a generated API can become trusted.
From a personal perspective, I learned a lot about UiPath from zero: browser automation, HTTP requests, Flowchart routing, human approval, exception handling, and how UiPath can work together with external agents and APIs. Even though the final project is not perfect, the process helped me understand how AI agents, RPA, APIs, and human governance can fit together in a real enterprise architecture.
What's next
The next step is to make the project more production-like.
First, I would improve the UiPath side with Orchestrator Assets, Queues, Action Center, UiPath Apps, and stronger test cases. This would make the demo closer to a real enterprise deployment.
Second, I would continue the cloud modernization plan: deploy the backend services, make configuration environment-based, add better authentication, persist memory in a managed database, and connect UiPath processes to cloud-hosted services.
Third, I would expand the capability evolution loop. When the system repeatedly sees similar capability gaps, it should generate a workflow or API proposal, require human review, run validation, and only then register the new capability for reuse.
The long-term vision is not to replace UiPath with agents. It is to use UiPath as the governed orchestration layer that connects robots, agents, humans, validation, and trusted tools.
Final positioning:
From fragile clicks to trusted capabilities — governed by UiPath.
Log in or sign up for Devpost to join the conversation.