How to Build a Procurement and Vendor Management System with AI

It started with a single email. "Need 20 laptops for the new engineering hires — can someone process this?" That email landed in our shared procurement inbox, got forwarded to three people, sat in a draft PO for six days, and ultimately required seven back-and-forth messages to clarify specs, budget codes, and delivery addresses. By the time the order went through, the laptops arrived three weeks late and the new hires spent their first week sharing machines.

That's when we realized procurement at our company was a mess. And I'm guessing it might be at yours too.

Here's what we were dealing with: purchase requests scattered across email inboxes, supplier contracts living in a chaotic shared drive with filenames like "contract_final_v3_REALLYFINAL.docx," PO approvals that required manual routing to the right manager, and absolutely zero visibility into vendor performance. We had spreadsheets tracking spreadsheets. It wasn't just inefficient — it was costing us money in late fees, missed discounts, and wasted hours.

So we decided to build an AI-powered procurement and vendor management system using INFORMAT. Here's exactly how we did it, what worked, what didn't, and what we'd do differently.

Why AI Actually Makes Sense for Procurement

Before diving into the build, let's address the obvious question: why not just buy an off-the-shelf procurement platform? There are dozens of them — Coupa, SAP Ariba, Procurify. They're powerful, sure. But they're also expensive, rigid, and require months of implementation. We needed something that worked with our existing workflows, not something that forced us into a predefined cage.

Here's where AI changes the calculus. Instead of configuring modules and mapping data fields for weeks, we could describe our procurement process in natural language and have the system generate the workflow. Instead of manually coding approval routing rules, we could train the AI on our actual approval patterns. Instead of maintaining vendor databases by hand, the system could extract and organize supplier information automatically from emails and documents.

Let's be honest: the first version we built was not perfect. But the speed from idea to working prototype was staggering — we had a functional procurement assistant running in hours, not months.

The Core Problems We Needed to Solve

Before building anything, we mapped out exactly what was broken:

• Request chaos: Purchase requests came in via email, Slack, and sometimes just someone tapping you on the shoulder. No standardization, no tracking.
• Approval black holes: Once a PO was created, nobody knew where it was in the approval chain. Was it with the manager? Finance? Legal? Unknown.
• Supplier fragmentation: We had over 200 active vendors and exactly zero centralized records of their performance, pricing, or contract terms.
• Manual data entry: Invoice matching, PO generation, vendor onboarding — all done by humans copying data from one place to another.
• No analytics: We couldn't answer basic questions like "which vendors have the best on-time delivery rate" or "what's our average PO approval time."

We needed a system that could ingest our existing chaotic data, learn our processes, and gradually automate the repetitive parts while keeping humans in the loop for decisions that actually needed judgment.

Building the Procurement Agent with INFORMAT

We used INFORMAT's agent builder to create what we called the "Procurement Assistant" — an AI agent that could handle the end-to-end procurement workflow. Here's how we approached each piece.

Step 1: Automating Purchase Request Intake

The first thing we tackled was the intake problem. We created an agent that could receive purchase requests from multiple channels (email forward, Slack message, web form) and extract structured data from them.

The prompt we used for the intake agent:

This alone saved us hours. Instead of a procurement person reading each email and manually typing up a request summary, the agent would parse the message, flag missing information, and auto-generate a structured request. The requester would get an immediate confirmation with a tracking ID. No more "did you get my email?" messages.

Step 2: Intelligent PO Generation

Once a request had all the required information, the next step was turning it into a formal purchase order. We built a PO generator agent that would pull vendor information from our supplier database (more on that below), apply standard terms based on the vendor category, and generate a properly formatted PO document.

Here's what the PO generation prompt looked like:

We'll be straight with you: the first few generated POs had issues. It mixed up payment terms for a couple of vendors and once applied the wrong tax rate. That's why we kept human review in the loop — the agent drafts, the human approves. But even with the mistakes, it cut PO creation time from 20 minutes to about 3 minutes.

Step 3: Building the Vendor Management Database

This was the messiest part. We had vendor information everywhere — contract files, email threads, sticky notes, a half-abandoned CRM. We needed a single source of truth.

We used INFORMAT to build a vendor management module that could ingest our existing documents and extract structured vendor records. We pointed it at our shared drive folder of contracts, and it read through every PDF and DOCX, extracting vendor names, contract dates, renewal terms, pricing, and contact information.

The vendor extraction prompt:

This processed about 80% of our contracts correctly on the first pass. The remaining 20% were scanned PDFs with handwritten notes or unusual formatting that needed manual cleanup. But going from 200+ unorganized files to a searchable vendor database in an afternoon felt like cheating.

The Approval Workflow: Where AI Shined (and Stumbled)

The approval workflow was the most complex piece. Different departments had different approval chains. Small purchases under $500 didn't need any approval. Purchases between $500 and $5,000 needed a manager. Over $5,000 needed a director. Over $25,000 needed VP and finance. Software purchases needed IT review. Consulting contracts needed legal.

We built a routing agent that would analyze each PO and automatically determine the approval chain based on the amount, category, department, and vendor. The agent would then send approval requests sequentially (or in parallel for multi-signer approvals) and track responses.

"We saw PO approval times drop from an average of 4.2 days to 14 hours in the first month. The biggest win wasn't speed — it was transparency. For the first time, requesters could see exactly where their PO was in the process without pinging someone." — Operations Director, early adopter

But here's where we hit friction: the routing agent initially struggled with edge cases. Like when a manager was on leave and the system didn't know about the temporary delegate. Or when a PO straddled two budget categories and neither director wanted to own the approval. The agent would get stuck in "pending" limbo and we'd only notice when someone complained.

We fixed this by adding escalation rules: if an approval step sits for more than 48 hours, the agent automatically escalates to the next level and notifies the requestor. We also added a manual override — any human could reassign or reroute a stuck approval. The goal was augmentation, not replacement.

How INFORMAT Compares to Other Approaches

We evaluated several approaches before settling on this path. Here's the honest comparison:

Off-the-shelf SaaS is the right choice if you have the budget, the time, and your procurement process is relatively standard. Custom development makes sense if you have specific compliance or integration requirements that no platform can handle. But for most mid-sized companies that just need to get organized and automate the busywork, the AI agent approach hits a sweet spot that neither of those options can touch.

One thing we should flag: INFORMAT won't handle your tax compliance or generate SOX-compliant audit trails (yet). For heavily regulated industries, you'll still want a traditional system for the compliance layer. But for day-to-day procurement operations? It's surprisingly capable.

Vendor Scoring and Performance Tracking

Once we had the vendor database populated and POs flowing through the system, we added what turned out to be our favorite feature: automated vendor scorecards. Every time an order was delivered, we'd send a brief feedback form to the requester asking about delivery time, quality, and communication. The agent would compile this into a running vendor score.

We also connected the system to our email to automatically track vendor responsiveness. If a vendor took more than 24 hours to respond to a quote request, that dinged their score. If they consistently delivered early, that boosted it.

The prompt for vendor scoring:

This turned vendor reviews from a once-a-year manual exercise into a continuous, data-driven process. When contract renewals came up, we had actual data to inform negotiations — not just gut feelings about which vendors were "good."

What We'd Do Differently

No article like this is complete without being honest about what went wrong. Here's our list:

1. We over-automated too fast. In the first week, we tried to make the agent handle everything automatically. Bad idea. When a PO for $50,000 in server hardware got auto-generated without director approval (because we'd misconfigured the category threshold), we realized we'd moved too fast. Slow down. Start with read-only and draft mode, then gradually increase autonomy as you validate the logic.

2. We underestimated data quality issues. Our contract files were in worse shape than we thought. The agent did an admirable job extracting data from messy documents, but we spent a solid week cleaning up vendor records after the initial import. Budget time for this — it's not the AI's fault; it's the mess we'd created over years.

3. We didn't train requesters properly. Just because the AI could parse natural language didn't mean people wrote clear requests. We kept getting "I need stuff for the project" type submissions. We had to build a simple request form with guided fields alongside the free-form input to get usable data.

4. We ignored integrations at first. Our accounting system (QuickBooks) and the procurement agent didn't talk to each other initially. That meant approved POs had to be manually entered into the accounting system — defeating half the purpose. We eventually connected them via INFORMAT's API, but this should have been step one, not an afterthought.

Where to Start If You Want to Build This

If you're reading this and thinking "our procurement is exactly this broken," here's a practical starting plan:

Week 1: Set up the intake agent. Just getting purchase requests into a structured format with tracking IDs will reduce chaos immediately. Don't worry about approvals or vendor databases yet.

Week 2: Add the PO generation agent in draft mode. Have it create POs that a human reviews before sending. This is where you'll catch the most quirks in your process.

Week 3: Point the vendor extraction agent at your contract files. Accept that the output will be imperfect and budget a couple of days for cleanup. But get that vendor database built — it's the foundation for everything else.

Week 4: Start layering in approval routing. Begin with simple approval chains (amount-based only), then add complexity like category routing and escalation rules. Keep humans as the final approvers until you're confident in the logic.

Beyond: Add vendor scorecards, connect to your accounting system, build dashboards for spend analysis, and gradually increase the autonomy of the system as trust builds.

The Bottom Line

Building a procurement and vendor management system with AI isn't about replacing procurement teams — it's about making them infinitely more effective. The weeks we saved on PO creation and approval routing meant our procurement team could actually focus on strategic work: negotiating better vendor terms, finding alternative suppliers, and building real relationships with key partners instead of drowning in email.

Is INFORMAT the perfect platform? No. We hit friction points, made mistakes, and had to backtrack plenty of times. But the speed from idea to working system was unlike anything we'd experienced with traditional software. Eight hours of building got us what would have taken eight weeks with a low-code platform or eight months with custom development.

For a mid-sized company drowning in procurement chaos, that speed matters more than polish. You can always refine later — but you can't get back the weeks you're losing to manual procurement today.