Speaker 1: You spend half your day waiting for approvals. Someone's on vacation,
Speaker 1: someone else didn't see the email, and by the time
Speaker 1: a decision finally arrives, the context that justified the request
Speaker 1: has expired. Corporate purgatory progress paused by people who swear
Speaker 1: they're busy. Now, picture a system that simply doesn't wait,
Speaker 1: a workflow that moves forward the instant conditions are met.
Speaker 1: Enter Microsoft Copilot Studios Agent flows, the bureaucracy killer disguised
Speaker 1: as automation. Here AI becomes your first approver. It reads
Speaker 1: the data, evaluates it against policy, and gives an informed
Speaker 1: approve or reject before any human blinks. Only borderline cases
Speaker 1: ever reach a manager's inbox, which means speed without sacrificing oversight,
Speaker 1: and Unlike legacy approval flows that collapse under conditional complexity,
Speaker 1: these AI driven ones scale branching, validating and auditing themselves
Speaker 1: along the way. In this walkthrough, I'll show you how
Speaker 1: to build a multi stage conditional approval system that decides
Speaker 1: faster than your colleagues can find the reply all button.
Speaker 1: You'll learn how to set up an AI stage with
Speaker 1: custom approval logic, add targeted human reviews, design, dynamic condisitions
Speaker 1: that reroot intelligently and integrate real document validation for compliance.
Speaker 1: By the end, you'll have an automated process that knows
Speaker 1: when to think like a machine and when to defer
Speaker 1: to human judgment. Stop following a queue, start letting logic lead.
Speaker 1: The problem with traditional approvals. Traditional approval chains are a
Speaker 1: tragic remix of the same inefficiency. Someone submits a form,
Speaker 1: emails fly, spreadsheets drift out of sync, and between forwarding loops,
Speaker 1: nobody remembers which version was final. Each participant adds delay,
Speaker 1: not value. The process doesn't manage the work, it manufactures
Speaker 1: latency typical power automate approval flows try to solve this,
Speaker 1: but they stall once you introduce nuance. A single approval
Speaker 1: path works fine if you only need one yes or no.
Speaker 1: The moment you add management layers, spending thresholds, or specialized rules,
Speaker 1: the design begins to splinter. You end up nesting conditions
Speaker 1: like Russian dolls, inelegant, fragile, and impossible to debug. Six
Speaker 1: months later, one broken connector and the entire system silently fails.
Speaker 1: Humans become the bottlenecks, or, to be brutally accurate, latency
Speaker 1: notes every message They receive becomes another asynchronous round trip email.
Speaker 1: As an approval mechanism is like using carrier pigeons in
Speaker 1: a fiber optic world. It technically works, but it shouldn't.
Speaker 1: Anti Microsoft Copilot Studio, this is not just an incremental
Speaker 1: version of power Automate. It introduces agent flows approval systems
Speaker 1: powered by AI, yet fully integrated into your organizations data sources, roles,
Speaker 1: and logic structures. It bridges deterministic policy enforcement with adaptive
Speaker 1: decision making. The brilliance lies in how it separates stages
Speaker 1: automated where you want speed, human where you still require validation.
Speaker 1: Think of it as hierarchy re engineered. The AI stage
Speaker 1: evaluates fixed rules, amount limits, category types, date ranges with
Speaker 1: clinical efficiency. Then if a decision teters on ambiguity, the
Speaker 1: process escalates to human oversight without forcing every trivial case
Speaker 1: to queue up. This alone eliminates exponential delay. Instead of
Speaker 1: ten people performing serial reviews, AI handles eighty percent instantly,
Speaker 1: routing only outliers and Yes, Copilot Studio tracks everything through
Speaker 1: its data verse backbone, producing verifiable logs without your team
Speaker 1: needing to dig through mailbox archives. Previous workflows were built
Speaker 1: for humans. Agent flows are built around them, keeping people
Speaker 1: in the loop only when interpretation not repetition, is required.
Speaker 1: Once you see how this architecture functions, traditional approvals will
Speaker 1: feel primitive, like balancing checkbooks by candlelight. The stakes are simple, compliance, consistency,
Speaker 1: and scale. Modern operations drown without automated validation, and AI
Speaker 1: assisted logic is now the baseline for reliability. When you
Speaker 1: migrate from static flows to conditional, auditable agent flows, you
Speaker 1: stop managing approvals reactively and start treating them as living systems.
Speaker 1: The difference is not just speed, its structural sanity. Building
Speaker 1: the AI stage, teaching the first approver now comes the
Speaker 1: interesting part. Training your first digital bureaucrat the AI stage
Speaker 1: is the logical gatekeeper of your approval process. Its job
Speaker 1: is not to think like a human, but to perform
Speaker 1: structured reasoning at superhuman consistency. It reads instructions, checks them
Speaker 1: against inputs, and outputs one of two verdicts approved or rejected.
Speaker 1: No politics, no coffee breaks. You begin by defining a
Speaker 1: new agent flow. At creation, the AI stage sits front
Speaker 1: and center, like an empty exam paper, waiting for its
Speaker 1: question key. The trigger usually comes from data verse, a
Speaker 1: record added or modified in your claims or expense table.
Speaker 1: Once a claim is created, this stage activates, evaluates the data,
Speaker 1: and decides accordingly. Inside the stage, the most important field
Speaker 1: is the instruction prompt, the brain of the operation. This
Speaker 1: is where you describe the approval logic in plain but
Speaker 1: rigorous language. Write it as if you're instructing a lawyer
Speaker 1: who never improvises. For example, approve the claim if the
Speaker 1: amount is less than five hundred, the description supports physical
Speaker 1: or mental health, and the purchase date is within thirty
Speaker 1: days of submission. Reject if any rule fails, that's it
Speaker 1: binary clarity. Next, define your dynamic inputs. Think of them
Speaker 1: as variables, feeding real data into your logic. You'll most
Speaker 1: likely include an amount, a description, and a purchase date.
Speaker 1: Each is added as content, text, or number inputs that
Speaker 1: the AI will pass when making a decision. Copilot Studio
Speaker 1: classes these inputs by type text, number or image. Document.
Speaker 1: Choose correctly because mixing types, say a number stored as
Speaker 1: text confuses both humans and machines. Beneath each input, provide
Speaker 1: sample data for testing. This acts as scaffolding while you
Speaker 1: calibrate logic. For instance, enter an example claim like fitness
Speaker 1: yoga mat amount three hundred, purchase date August twenty second.
Speaker 1: When you hit test copilot, studio runs the reasoning model
Speaker 1: GPT based under the hood, and outputs the decision plus
Speaker 1: an explanation. If the outcome matches your expectation, good. If not,
Speaker 1: your instructions lack determinism, and that's where most beginners mess up.
Speaker 1: Broad or ambiguous phrasing. Reasonable expense, recent purchase is AI poison.
Speaker 1: The system can't read corporate mood. It needs mathematical definitions,
Speaker 1: So refine your instructions relentlessly until the test results are consistent.
Speaker 1: Every time you reword, you're tuning the judgment engine for reproducibility.
Speaker 1: The pattern you want is identical input producing identical output
Speaker 1: every time, machine logic, not office gossip. Once your PROMPT
Speaker 1: yields reliable decisions across multiple test cases, you've effectively trained
Speaker 1: your AA approver. Now inject the real dynamic data using
Speaker 1: tokens pulled from data verse claim amount details, purchase or
Speaker 1: submission date. These replace your test values during live runs.
Speaker 1: From that point on, the AI evaluates each claim in context,
Speaker 1: returning an approval verdict the moment new data appears, before
Speaker 1: declaring victory run iterative tests. Change the amount to six hundred,
Speaker 1: does it reject? Change the date to three months ago?
Speaker 1: Does it flagg as invalid? Add a nonsensical claim like
Speaker 1: iPad purchase. Does it detect the mismatch? Each pass should
Speaker 1: demonstrate consistent cause and effect. If responses fluctuate, the issue
Speaker 1: is your prompt clarity, not the AI model. When consistent
Speaker 1: patterns emerge, establish a naming convention for your content variables
Speaker 1: prefixes like starclaim amount for strings or nun purchase date
Speaker 1: for numeric values. This tiny discipline prevents chaos when you
Speaker 1: expand later into multi branch logic. At this stage, your
Speaker 1: automated approver can now make independent decisions based on policy
Speaker 1: without supervision. But automation isn't dictatorship, its delegation. The machine
Speaker 1: handles speed and precision, not judgment. For borderline scenario, you'll
Speaker 1: need escalation a human in the loop to review what
Speaker 1: the AI declines or deems uncertain. That's where the next
Speaker 1: stage comes into play, and that's how authority gets shared
Speaker 1: between silicon and staff, adding human oversight multi stage and
Speaker 1: conditional logic. Once your AI stage is confidently judging claims,
Speaker 1: you can add what bureaucracies ironically call the human touch
Speaker 1: in copalate studio. That means a manual stage, a checkpoint
Speaker 1: where a real person gets to exercise discretion. Think of
Speaker 1: it as your safety valve. Everything predictable flows past automatically.
Speaker 1: Anything nuanced lands on a manager's desk. You start in
Speaker 1: the approval designer by adding a manual stage right after
Speaker 1: the AI one. This creates a second gait in your
Speaker 1: agent flow. The handoff is conditional only if the AIS
Speaker 1: verdict equals approved, do we proceed to the human stage.
Speaker 1: If the AIS has rejected, the process ends right there.
Speaker 1: Why waste time asking managers to confirm what policy already disqualified?
Speaker 1: Efficiency is selective attention dressed as automation. Let's set up
Speaker 1: an example scenarios. Suppose an employee submits an expense claim
Speaker 1: for gym membership. The AI approves it because all criteria
Speaker 1: fit the policy. Now that decision triggers a manager level
Speaker 1: manual stage called manager approval. Under the hood, you configure
Speaker 1: this stage with a title like claim approval Request from
Speaker 1: Claim submitter. Those variables pull data dynamically from data verse.
Speaker 1: The assigned to field is where you define who receives
Speaker 1: the task, typically the claimant's manager. To automate this routing,
Speaker 1: copilot studio lets you integrate the office three sixty five
Speaker 1: users connector. First grab the user record of whoever created
Speaker 1: the claim using the get row by ID action on
Speaker 1: the user table in data verse that retrieves the submitter's information. Next,
Speaker 1: the get manager action fetches that users manager via their
Speaker 1: primary email. Pass that result back into your manual stage
Speaker 1: as a variable like estair manager email result. No hard coding,
Speaker 1: no stale hierarchies, managers change, hierarchy refreshes itself, now comes
Speaker 1: conditional branching, the real reason multi stage approvals exist. You
Speaker 1: can introduce logic directly inside the agent flow. If claim
Speaker 1: amount is greater then or equal to one hundred and fifty,
Speaker 1: then add an additional stage for admin approval, otherwise end
Speaker 1: the process. As this turns a simple two step routine
Speaker 1: into a multi tiered decision tree that adapts to context.
Speaker 1: Low value claims get one human, higher value or risky
Speaker 1: claims escalate for extra eyes in the designer. Insert a
Speaker 1: condition action before closing the flow. Reference your numeric variable,
Speaker 1: perhaps numb claim amount, choose the operator greater than or
Speaker 1: equal to, and set the threshold, such as one hundred
Speaker 1: and fifty in the if true branch. At another manual
Speaker 1: stage named admin approval, assign it to a fixed approver
Speaker 1: like the compliance administrator in the if false branch, and
Speaker 1: as approved. The effect the workflow behaves like a rational
Speaker 1: organization instead of a universal bottleneck. A bit of practical
Speaker 1: humor applies here. Yes, delegation still requires trust, not wishful routing.
Speaker 1: Don't assign broad security roles that can approve everything. Restrict
Speaker 1: permissions to relevant users or groups through data verse role
Speaker 1: based access control. Otherwise you've automated anarchy. Testing this structure
Speaker 1: reveals how smoothly each piece fits. When a claim under
Speaker 1: one hundred and fifty dollars passes AI review, the flow
Speaker 1: ends after manl Man approval. When over one hundred and
Speaker 1: fifty dollars, the system politely accues it for ADMIN review
Speaker 1: before finalizing. Each path leaves an audit trail, the AI
Speaker 1: reasoning log time stamped approvals and recorded outcomes stored in
Speaker 1: data verse. No one can later claim I never saw it,
Speaker 1: the database says. Otherwise, as you refine, keep naming conventions,
Speaker 1: disciplined prefix human stages, clearly man approved admin approved, so
Speaker 1: you can trace branches visually. The flow chart should read
Speaker 1: like logic, not mystery art. Once satisfied, publish and test
Speaker 1: with real scenarios. Watch the chain unfold. AI evaluates instantly,
Speaker 1: manager gets a targeted approval, task edmin joins only when
Speaker 1: conditions warrant. The result feels less like automation doing everything
Speaker 1: and more like a transparent hierarchy that handles itself. This
Speaker 1: layered orchestration also exposes a new frontier document validation, because
Speaker 1: sometimes a form field lies but the receipt doesn't. The
Speaker 1: next step is to make the AI examine the physical
Speaker 1: evidence before it ever reaches your inbox. That's where receipt
Speaker 1: validation enters, turning bureaucracy into verifiable science, dynamic inputs and
Speaker 1: document validation. Let's talk about receipts, the tiny crumpled pieces
Speaker 1: of paper that mysteriously become critical evidence once someone wants reimbursement.
Speaker 1: In a manual approval process, humans verify them by eyeballing yes,
Speaker 1: that looks like a yoga mat, not a yacht. In
Speaker 1: an automated one, we make the AI perform the same
Speaker 1: check without judgment fatigue. In copilot studios, agent flows document
Speaker 1: validation comes to life through dynamic content inputs, specifically the
Speaker 1: ability to pass an image or file into your approval logic.
Speaker 1: This adds a third sense to your AI approver side.
Speaker 1: Instead of relying solely on text fields, the model reads
Speaker 1: the document and compares what's written against what was uploaded.
Speaker 1: Here's the structure inside your AI stage. You add a
Speaker 1: new input type called image or document. Label it clearly
Speaker 1: something like dock, receid file upload a sample receipt for testing.
Speaker 1: This doesn't go live, it just trains the logic layout.
Speaker 1: Now adjust your instruction prompt to include document cross validation.
Speaker 1: You extend your previous logic approve the claim if all
Speaker 1: the following are true. Amount five hundred, claim detail support
Speaker 1: physical or mental health purchas, date within thirty days, and
Speaker 1: the receipt document matches the declared item amount and date.
Speaker 1: This fourth condition transforms your AI approver from policy enforcer
Speaker 1: into forensic accountant. When the test runs, the model extracts
Speaker 1: readable text from the document and verifies consistency with your
Speaker 1: structured inputs. If the receipt lists fitness mat three hundred
Speaker 1: dollars August twenty seven, and your claim says anything else,
Speaker 1: the verdict flips to reject it. Now for implementation, before
Speaker 1: the approval runs, you'll need to fetch that document. Use
Speaker 1: the download a file or image action from data verse
Speaker 1: target the same table the claim record resides in likely
Speaker 1: claims under file column. Choose the attachment field often named
Speaker 1: something like receipt, then specify the row id dynamically from
Speaker 1: the trigger the unique claim identifier. This action returns file
Speaker 1: meta data and content. But here's the subtle trap. The
Speaker 1: content output needs slight surgery for the AI to interpret correctly.
Speaker 1: When mapping the file content into your dock receipt file input,
Speaker 1: open the expression editor and append content to the body
Speaker 1: reference that last week delivers the actual file bites rather
Speaker 1: than the metadata wrapper. Skip it and your AI will
Speaker 1: enthusiastically approve blank receipts. Let's address synchronization, the achilles heel
Speaker 1: of document workflows. Most data verse tables don't store attachments
Speaker 1: until after the record first saves, meaning if your flow
Speaker 1: triggers on record creation, it may fire before the file
Speaker 1: exists symptom flow fails, or the receipt content is null.
Speaker 1: The remedy is elegant. Change the trigger condition to on
Speaker 1: item modification but restricted to fire only when the receipt
Speaker 1: column changes that way. The moment someone uploads or replaces
Speaker 1: a file, validation kicks in. To configure this, open trigger settings,
Speaker 1: choose modified columns and paste the logical name of your
Speaker 1: receipt column retrievable from data verse column detail under advanced tools.
Speaker 1: Once set publish now, your automation behaves politely. It waits
Speaker 1: until there's actually something to validate. When the claim updates
Speaker 1: with a new receipt, the flow restarts. It downloads the file,
Speaker 1: feeds it through the AI stage, and cross checks all inputs.
Speaker 1: If discrepancies exist amount mismatch, outdated date, inconsistent descriptions, the
Speaker 1: AI rejects with explanation included. The reasoning blog might read
Speaker 1: claimed amound three hundred five dollars differs from document total
Speaker 1: three hundred dollars. That's compliance without complaint. The practical impact
Speaker 1: every submission becomes self auditing. Employees can no longer slip
Speaker 1: through questionable receipts or vague descriptions. AI provides the judgment,
Speaker 1: data Verse provides the evidence, and neither takes coffee breaks,
Speaker 1: so no document validation isn't overkill. It's immune memory for
Speaker 1: your workflows. Outliers get caught at the molecular level, the
Speaker 1: characters printed on actual receipts, and the human reviewer gets
Speaker 1: promoted from manual checker to exception handler. Congratulations, you've now
Speaker 1: automated honesty itself, building reliability, testing, versioning, and publishing. Any
Speaker 1: automation can look perfect until it runs. That's why reliability
Speaker 1: is not a phase, It's a discipline. Copilot Studio makes
Speaker 1: that discipline surprisingly civilized through versioning, testing, and publishing controls
Speaker 1: embedded directly into agent flows. Start with iterative testing. Every
Speaker 1: approval flow is a miniature ecosystem. Even one stray variable
Speaker 1: name can create chaos, so treat testing as a scientific process.
Speaker 1: Isolate changes, apply data, observe output in the flow editor.
Speaker 1: Copalot Studio lets you simulate sample data without deploying production triggers.
Speaker 1: Feed variant scenarios two large amount outdated, date irrelevant item names,
Speaker 1: and ensure each yields the correct verdict. Then move to
Speaker 1: naming conventions. Boring absolutely essential more than air prefix Every
Speaker 1: variable systematically sdr for strings, non pH numerics, dock for files. Likewise,
Speaker 1: label actions explicitly download receipt file check manager, approval update
Speaker 1: claim approved, because in three months, when someone asks why
Speaker 1: Action seven broke, you'll appreciate that breadcrumbs are friendlier than archaeology.
Speaker 1: Once individual tests succeed, expand to edge scenario validation. Pretend
Speaker 1: to be the incompetent user, upload no receipt, change a
Speaker 1: date to next year, type five hundred instead of five hundred.
Speaker 1: Confirm the AI explains and rejects without crash. These aren't
Speaker 1: hypothetical screw ups, their reality rehearsals. The more failure cases
Speaker 1: you neutralize upfront, the fewer two AM team's messages you'll
Speaker 1: get later saying the flow stopped again. Publishing introduces governance.
Speaker 1: Each time you save a major change, co pilot studio
Speaker 1: quietly creates a new version you can revert any time,
Speaker 1: no overright anxiety. Use this to keep experimental logic sandboxes
Speaker 1: apart from production. One flow named claim approval DEV, another
Speaker 1: Claim approval PROD test in DEV. Publish only when stable. Remember,
Speaker 1: reliability isn't just about correctness, it's about control under change.
Speaker 1: After publishing, leverage the activity logs. They're not decorative. They're
Speaker 1: legal grade records of AI and human interactions. Time stamps,
Speaker 1: approver identities, reasoning summaries review these logs periodically. Patterns reveal themselves,
Speaker 1: which rules trigger most rejections, which managers overrule the AI
Speaker 1: how often compliance steps engage Those insights refine both policy
Speaker 1: and design. Another subtle best practice automated status updates back
Speaker 1: in to data verse records at the end of each branch.
Speaker 1: The update a row action should set a clear field
Speaker 1: like claim status exlors approved or rejected. This visible endpoint
Speaker 1: reinforces trust. Users see decisions inside their own table views.
Speaker 1: No separate tracking spreadsheet, no phantom approvals. Once your system
Speaker 1: passes all tests hit published with quiet confidence. Unlike earlier
Speaker 1: generations of power automate flows, agent flows retain contextual metadata,
Speaker 1: the AI decision schema, dynamic content bindings, and version tags.
Speaker 1: The result is not just a running process, but a
Speaker 1: reproducible artifact auditable automation. The final reliability check is mental
Speaker 1: resist over engineering. Sometimes a failed flow reveals over complex rules,
Speaker 1: not technical bugs, streamline logic where possible, fewer stages, clearer instructions,
Speaker 1: minimal ambiguity. Automation's enemy isn't randomness, its unnecessary cleverness. When
Speaker 1: you finish this stage, your approval system achieves operational maturity, tested,
Speaker 1: version rowback, friendly and verifiable. Every outcome from AI judgment
Speaker 1: to admin sign off leaves a digital footprint that's stands
Speaker 1: up to scrutiny. That's reliability quantified, not a vibe, not luck,
Speaker 1: just structured reasoning recorded faithfully by the tools you build
Speaker 1: to think while you sleep, results in real world payoff.
Speaker 1: What happens when you hand bureaucracy to mathematics. The approvals
Speaker 1: stop waiting. An AI driven multi stage agent flow cuts
Speaker 1: turn around from days to minutes. Because decisions no longer
Speaker 1: depend on calendar availability. Every claim that meets objective policy
Speaker 1: is approved instantly. Every edge case lands neatly in a
Speaker 1: manager's queue with the context already attached. Humans make value judgments,
Speaker 1: not clerical confirmations. The impact appears first as time compression.
Speaker 1: A reimbursement that once required four emails and two reminders
Speaker 1: now resolves before lunch. Departments experience shorter processing cycles, less
Speaker 1: idle status, and perfectly logged reasoning trails. The approval mechanism
Speaker 1: ceases to be an interruption. It becomes infrastructure. Then comes
Speaker 1: error reduction. By enforcing deterministic rules through AI, you remove
Speaker 1: subjective drift. The bane of manual approvals. No more I
Speaker 1: thought discounted as health and wellness. The AI interprets criteria
Speaker 1: the same way every time. Consistency scales better than compassion.
Speaker 1: In administrative logic, managers deal only with anomalies, and even
Speaker 1: those come with a full audit trail. Data inputs, decision history,
Speaker 1: model explanation, audits transform from panic exercises into polite verifications.
Speaker 1: On an organizational level, this isn't just faster, it's safer.
Speaker 1: Compliance doesn't rely on memory or mood, it's embedded. The
Speaker 1: data verse logs show who approved, when and why. That
Speaker 1: transparency discourages short cut culture because every decision now lives
Speaker 1: in searchable permanence and Philosophically, the workflow flips from human
Speaker 1: first with AI assistance to AI first with human correction
Speaker 1: practical governance not science fiction. AI handles rule enforcement, humans
Speaker 1: handle judgment. The hybrid produces fairer, faster, and ultimately more
Speaker 1: trustworthy systems. Imagine explaining that to an auditor the kind
Speaker 1: of smile that follows is worth the automation alone. So
Speaker 1: there it is. Microsoft Copilot Studio isn't just another automation tool.
Speaker 1: It's the place where your organization's indecision finally retires. Built
Speaker 1: an approval engine that can think in conditions, escalate, responsibly,
Speaker 1: validate receipts against reality, and document every move it makes.
Speaker 1: That's not a flow, it's a governance model. If you
Speaker 1: remember nothing else, remember this AI should make decisions predictable
Speaker 1: and humans exceptional. Stop roting everything through people out of habit.
Speaker 1: Let logic handle the routine so managers can handle exceptions. Now,
Speaker 1: if this walkthrough saved you from another week of pending
Speaker 1: manager review, consider subscribing. The next tutorial dives deeper into
Speaker 1: advanced copilot studio automations, where these agent flows connect with
Speaker 1: power platform analytics and adaptive policies. Lock in your upgrade path, subscribe,
Speaker 1: turn on alerts, and let new episodes deploy automatically. No
Speaker 1: manual checks, no mist releases, just continuous delivery of useful knowledge.
Speaker 1: Proceed