If you’ve ever spent a Friday afternoon chasing invoice approvals—only to have a vendor email Monday morning asking “Any update on payment?”—you already know the AP follow-up problem isn’t just annoying. It’s expensive, distracting, and weirdly hard to “fix” with more reminders.
This post walks through how to cut AP follow-up time in half by building an **invoice approval and vendor status bot in Microsoft Teams** using Power Automate, Dataverse, and the native Approvals experience. Before diving into solutions, let’s understand the problem: most SMBs don’t actually lack effort. They lack a reliable system of record, clear routing rules, and automated status communication. Once you put those three pieces in place, vendors stop asking as often—because they’re not left guessing.
## Chapter 1: The AP Follow-Up Problem in SMBs (where time gets lost and why vendors keep asking)
The real question isn’t “Why is AP so busy?” it’s “Why is AP doing so much *status translation*?” In many SMBs, AP becomes the human API between vendors, approvers, inboxes, and spreadsheets. That’s where the hours go.
A big part of the pain is interruption-driven work. When your day is made of pings—Teams messages, emails, quick hallway questions—you end up reacting instead of processing. Microsoft has been blunt about this dynamic: modern work is dominated by constant interruptions and message overload, which makes repetitive “what’s the status?” traffic especially costly to handle manually (and mentally) per Microsoft’s 2025 Work Trend Index.
Vendors keep asking because late payments and disputes remain common across B2B, which trains suppliers to proactively chase status rather than wait quietly. That behavior shows up broadly in market research, including Atradius’ 2024 Payment Practices Barometer. If vendors have been burned before, they’ll ask again—especially when they can’t see where their invoice is stuck.
Here’s what that looks like in practice: AP receives an invoice, someone saves it to a folder, an approver misses an email, a manager is out, and the vendor follows up twice before anyone even notices the first approval request. By the time you’re “working the invoice,” you’ve already spent time answering questions about it.
### Signs You Need This (and it’s not just “we have too many invoices”)
– Approvals live in email threads and get forwarded multiple times.
– Vendors ask for status updates more than once per invoice.
– AP can’t confidently answer “Where is this invoice right now?” without searching.
– Escalations happen only after something becomes urgent (or overdue).
– You occasionally pay late fees or rush-pay to preserve a relationship.
## Chapter 2: Root Causes (no single source of truth, unclear approvers, manual handoffs, missing SLAs, scattered vendor comms)
Most businesses get this wrong by trying to “automate approvals” before they’ve defined what an approval *means* operationally. Approval is not a button—it’s a decision with rules, time expectations, and consequences.
### No single source of truth (aka “it’s in someone’s inbox”)
If invoice metadata (vendor, amount, due date, PO match status, approver, timestamps) isn’t stored centrally, you can’t reliably automate routing, reminders, or reporting. You can also end up with duplicate approvals because different people are looking at different copies of the same PDF.
This is where it gets interesting: the cost problem isn’t only labor. Manual invoice processes tend to be both slower and materially more expensive per invoice than automated approaches—benchmarks frequently show meaningful gaps in cost and cycle time between manual processing and top-performing automated teams, as reflected in APQC’s accounts payable benchmarking resources. When cycle time stretches, vendors follow up more, and “follow-up work” becomes a self-inflicted tax.
### Unclear approvers and routing rules
If “who approves this?” depends on tribal knowledge (or whoever shouts loudest), your workflow won’t be consistent. SMBs often have informal rules like:
– “Over $5K goes to the department head”
– “If it’s IT, ask the CTO”
– “If it’s a renewal, Finance wants a look”
Those rules can absolutely be automated—but only if you write them down.
### Manual handoffs + missing SLAs
Without defined SLAs (e.g., “manager approvals within 2 business days”), reminders are emotional (“please approve”) rather than operational (“approval due in 6 hours before escalation”). SLAs also give you a clean escalation path that doesn’t rely on AP being the bad guy.
### Scattered vendor communications
Vendors email AP, project managers, and whoever signed the contract. Then AP has to reconcile all of it. Without a structured status update mechanism, vendors will keep asking the same question in different places.
## Chapter 3: Solution Architecture (Teams-first experience + Dataverse as invoice system of record + Power Automate orchestration + Approvals)
A practical pattern for SMBs is: **Teams for the human experience, Dataverse for the truth, Power Automate for the plumbing.** Not because it’s fancy—because it prevents your process from dissolving into inbox archaeology.
### Teams-first experience: meet approvers where they already work
Approvers shouldn’t need to learn “the AP system” to approve an invoice. They should get a clear request, in context, inside Teams.
Microsoft explicitly supports this pattern with a native Approvals experience that integrates with Power Automate—approvers can receive and act on approvals in Teams without bouncing between tools, per Microsoft’s Power Automate approvals documentation. That matters for adoption: fewer clicks, fewer excuses.
### Dataverse as the invoice system of record
Dataverse gives you a secure, relational store for invoice state, timestamps, and communications history—plus auditing and security controls. Microsoft positions Dataverse for storing business data used across Power Platform with robust governance capabilities, as outlined in Microsoft’s Dataverse overview.
The key design decision: **Dataverse is where the invoice “is,” even if the PDF lives in SharePoint.** Your workflow should never depend on parsing an email thread to know status.
### Power Automate orchestration: event-driven, not “someone remembered”
Power Automate becomes your process engine:
– Create invoice record
– Determine approver(s)
– Start approval
– Track SLA timers
– Escalate
– Notify vendor at milestones
– Log everything
The goal is to make progress happen because the system moves it forward—not because AP nudged it again.
## Chapter 4: Build the Workflow Step-by-Step (Dataverse tables and statuses, intake methods, routing rules by amount/department, Teams approvals, SLA timers and escalations)
This chapter is the “how.” The steps below assume you’re building within Microsoft 365 + Power Platform, and you want the simplest durable version first (then iterate).
### Step 1: Define your Dataverse tables (keep it boring and reportable)
Start with a small set of tables:
**Invoice (core table)**
– Invoice Number (text)
– Vendor (lookup)
– Amount (currency)
– Invoice Date / Due Date (date)
– Department / Cost Center (choice or lookup)
– Status (choice)
– Current Approver (user)
– Received Timestamp / Submitted / Approved / Scheduled / Paid timestamps
– Source Document Link (URL to SharePoint file)
– External Reference (optional: PO number)
**Vendor**
– Vendor Name
– Primary Email (or AP email)
– Status Update Preference (opt-in/out)
– Throttle Setting (e.g., “no more than 1 update per day”)
**Approval History**
– Invoice (lookup)
– Approver (user)
– Decision (approved/rejected)
– Decision Timestamp
– Comments
**Vendor Communications Log**
– Invoice (lookup)
– Message Type (received/approved/scheduled/paid/etc.)
– Sent To
– Sent Timestamp
– Channel (email/Teams)
– Template Version
Statuses to include (minimum viable):
– Received
– In Review
– Pending Approval
– Approved
– Scheduled for Payment
– Paid
– On Hold (exception bucket)
– Rejected (with reason)
What good looks like: at any moment, AP can open one record and see who has it, how long it’s been there, and what the vendor has been told.
### Step 2: Decide intake methods (pick 1–2, not 6)
Common options:
– **Email to shared mailbox** → flow creates invoice record
– **SharePoint folder drop** → flow triggers on file creation
– **Microsoft Forms** (internal submission) → structured metadata from the start
– **Power Apps “Invoice Intake” app in Teams** → best control, slightly more build
For SMBs, a strong starting combo is:
1) SharePoint “Incoming Invoices” library (PDF storage)
2) A lightweight form (or Power Apps screen) to capture vendor/amount/due date if it isn’t extractable
### Step 3: Routing rules (make them explicit and testable)
Routing should be deterministic. Example logic:
– If Amount < $1,000 → auto-route to department budget owner
- If Amount between $1,000–$10,000 → department head approval
- If Amount > $10,000 → department head + Finance approval (sequential)
– If Vendor is “new” or “high risk” → add Finance review
– If PO exists and match is clean → fast path
Store routing thresholds in a small **Rules** table (or environment variables) so you can adjust without editing flows.
### Step 4: Create the approval in Teams (with the right fields)
Use Power Automate’s Approvals action to create an approval and post it where it will be seen:
– Approver(s)
– Title: “Invoice {Vendor} — {Amount} due {Due Date}”
– Details: link to document, cost center, PO, notes
– Outcome options: Approve / Reject / Request Info
Because Approvals is a supported Teams-centric pattern, your approvers can track and act without leaving Teams, per Microsoft’s documentation.
### Step 5: Add SLA timers and escalations (without becoming spammy)
This is where you actually cut follow-up time.
A practical SLA model:
– First reminder: 24 business hours after assignment
– Second reminder: 48 business hours
– Escalation: 72 business hours to manager or delegate
– Hard stop: mark as “On Hold” if no valid approver exists, notify AP lead
Implementation approach:
– When status becomes “Pending Approval,” write an SLA Due DateTime into the invoice record.
– Use a scheduled flow (runs hourly) to query invoices where:
– Status = Pending Approval
– Now() > Reminder1Time and Reminder1Sent = false, etc.
– Post adaptive card or Teams message reminder to the approver.
– On escalation, reassign approval (or create a new approval) and log it in Approval History.
Key tip: avoid infinite reminders. Escalate to a human owner and change the state so the system progresses.
### Questions to Ask (before you build routing + SLA logic)
– Who is accountable for approvals when the primary approver is out?
– What’s the maximum acceptable approval time by invoice type?
– Which invoices should *never* be auto-approved?
– What exceptions require AP review (missing PO, price discrepancy, new vendor)?
– What reporting do you want in 30 days (cycle time, bottlenecks, aging)?
## Chapter 5: Automate Vendor Status Updates (event-driven messages at received/approved/scheduled/paid stages, templates, throttling, and opt-out handling)
Vendors ask “where’s my payment?” when silence lasts too long. The simplest way to reduce inquiries is to proactively send short, consistent updates at moments that matter.
Before diving into solutions, let’s understand the problem: vendors don’t need your internal workflow details—they need confidence. Your bot’s job is to provide that confidence without creating new work for AP.
### Choose milestone events (don’t narrate every internal step)
Good milestones for most SMBs:
– **Received**: “We received invoice X on DATE and it’s in review.”
– **Approved**: “Invoice X has been approved and is queued for payment.”
– **Scheduled**: “Payment is scheduled for DATE via METHOD.”
– **Paid**: “Payment was sent on DATE; reference/trace ID…”
You can also send **On Hold** with a clear action request (e.g., “Please resend W-9” or “PO number needed”). That’s not a status update; it’s an unblocker.
### Template messages (short, consistent, and logged)
Example: Approved template
Subject: Invoice {InvoiceNumber} approved
Body:
Hi {VendorName},
Invoice {InvoiceNumber} for {Amount} has been approved on {ApprovedDate}. Next step is scheduling payment. If you have questions, reply to this email and include the invoice number.
—Accounts Payable
Store templates in Dataverse (or a SharePoint list) with a Template Version so you can improve them without rewriting flows.
### Throttling (because nobody wants 12 updates in a day)
Rules of thumb:
– No more than **1 proactive update per invoice per day**
– Skip “Received” updates for vendors who opted out
– If a vendor replies with a question, pause automation and flag AP (don’t auto-respond into a back-and-forth)
Implementation:
– When invoice status changes, trigger a flow:
– Check Vendor preference (opt-in/out)
– Check last message timestamp in Vendor Communications Log
– If within throttle window, queue or skip
– If send, log it
### Opt-out handling (simple and respectful)
Add an opt-out line: “Reply ‘OPT OUT’ to stop automated status updates.”
When email arrives:
– If body contains “opt out” (case-insensitive), update Vendor.StatusUpdatePreference = Opted Out
– Confirm the change once
This avoids the awkward situation where your “helpful” bot becomes the thing vendors complain about.
## Chapter 6: Common Pitfalls and Governance (permissions, duplicate invoices, exception handling, audit trails, environment strategy, DLP policies)
Automation projects don’t fail because Power Automate can’t send an approval. They fail because the business process is fuzzy, ownership is unclear, and workarounds are easier than compliance. This is a well-worn warning in automation guidance, including change-management and operating-model emphasis in Deloitte’s automation insights.
### Common Mistakes (that quietly recreate the same old chaos)
– **No duplicate detection**: same invoice gets entered twice (different filename, same invoice number).
– **Approver ambiguity**: approvals bounce around because no one “owns” the decision.
– **Exception black hole**: invoices marked “On Hold” but never revisited.
– **Over-notifying**: reminders every few hours → everyone ignores them.
– **No audit trail**: you can’t prove who approved what, when, and why.
### Permissions and auditability (design for “who can see what”)
Invoices can contain sensitive pricing and banking details. Use Dataverse security roles and limit access by:
– AP team: full read/write
– Department approvers: read-only except approvals/comments
– Executives: reporting dashboards only
Dataverse supports security and auditing capabilities suitable for business records, as described in Microsoft’s Dataverse overview. Turn on auditing for key tables/fields (Status, Amount, Vendor, Approval decision).
### Environment strategy + DLP (so “one flow” doesn’t become a data leak)
Even SMBs should separate:
– **Dev/Test environment** (build safely)
– **Prod environment** (run the business)
And apply Data Loss Prevention policies to control which connectors can mix with business data. Microsoft provides practical governance guidance—including environment strategy and DLP policies—in Power Platform governance documentation.
### Exception handling (decide in advance, not during a crisis)
Define paths for:
– Missing PO / mismatch
– New vendor onboarding required
– Invoice dispute
– Approver out-of-office
– Partial approvals (split coding)
Your flow should route exceptions to an AP queue (Teams channel or Dataverse view) with a clear reason code. If everything is an exception, nothing is.
## Chapter 7: Measuring Success and Next Steps (cycle time, late fees avoided, inquiry volume reduction, duplicate payment prevention, iteration roadmap)
If you don’t measure it, you’ll end up with “a workflow” but no proof it reduced follow-up.
### Metrics that matter (and map to real dollars/time)
– **Invoice cycle time**: Received → Approved → Paid
Benchmarks and improvement targets are often grounded in industry measures like those published by APQC.
– **Approval aging by approver/department**: where SLAs are consistently missed
– **Vendor inquiry volume**: count emails to AP mailbox with “status” keywords (before vs after)
– **Late fees avoided / rush payments reduced**: even a few incidents can fund the project
– **Duplicate payment prevention**: duplicates caught by invoice number + vendor + amount checks
Here’s what that looks like in practice: after 30 days, you should be able to pull a report showing (1) average approval time, (2) top bottlenecks, and (3) how many proactive vendor updates were sent—and correlate that with fewer inbound “where’s my payment?” messages.
### Next steps: iterate in the direction of fewer exceptions
A sensible roadmap:
1) Nail the core workflow (intake → approval → paid) with clean statuses
2) Add exception types one at a time (PO mismatch, missing W-9, disputed invoices)
3) Improve vendor comms templates based on real replies
4) Add dashboards (Power BI) for aging, SLA compliance, and workload balancing
5) Consider OCR/extraction later—only after your state machine is solid
## Closing
Cutting AP follow-up time in half usually isn’t about hiring more people or sending more reminders—it’s about building a workflow that creates clarity automatically. A Teams-centric invoice approval flow gives approvers a simple place to act, Dataverse gives you a dependable system of record, and Power Automate makes SLAs, escalations, and vendor updates run without AP playing air-traffic controller.
Three ideas to keep: centralize invoice state (stop hunting through inboxes), enforce time expectations with SLAs (stop “friendly nudges” as a process), and proactively message vendors at meaningful milestones (stop repeat status pings).
Take 10 minutes to list your top 5 AP follow-up scenarios (late approvals, missing approvers, vendor status requests, exceptions, duplicates). Which one would disappear first if your invoices had a single status everyone could trust?
