WEBVTT

1
00:00:00.080 --> 00:00:03.200
<v Speaker 1>You spend half your day waiting for approvals. Someone's on vacation,

2
00:00:03.319 --> 00:00:05.719
<v Speaker 1>someone else didn't see the email, and by the time

3
00:00:05.719 --> 00:00:08.720
<v Speaker 1>a decision finally arrives, the context that justified the request

4
00:00:08.720 --> 00:00:12.240
<v Speaker 1>has expired. Corporate purgatory progress paused by people who swear

5
00:00:12.240 --> 00:00:14.919
<v Speaker 1>they're busy. Now, picture a system that simply doesn't wait,

6
00:00:15.240 --> 00:00:18.000
<v Speaker 1>a workflow that moves forward the instant conditions are met.

7
00:00:18.600 --> 00:00:22.000
<v Speaker 1>Enter Microsoft Copilot Studios Agent flows, the bureaucracy killer disguised

8
00:00:22.000 --> 00:00:25.079
<v Speaker 1>as automation. Here AI becomes your first approver. It reads

9
00:00:25.079 --> 00:00:28.440
<v Speaker 1>the data, evaluates it against policy, and gives an informed

10
00:00:28.600 --> 00:00:32.439
<v Speaker 1>approve or reject before any human blinks. Only borderline cases

11
00:00:32.479 --> 00:00:36.159
<v Speaker 1>ever reach a manager's inbox, which means speed without sacrificing oversight,

12
00:00:36.280 --> 00:00:39.759
<v Speaker 1>and Unlike legacy approval flows that collapse under conditional complexity,

13
00:00:40.200 --> 00:00:44.560
<v Speaker 1>these AI driven ones scale branching, validating and auditing themselves

14
00:00:44.600 --> 00:00:46.840
<v Speaker 1>along the way. In this walkthrough, I'll show you how

15
00:00:46.840 --> 00:00:49.880
<v Speaker 1>to build a multi stage conditional approval system that decides

16
00:00:49.920 --> 00:00:52.439
<v Speaker 1>faster than your colleagues can find the reply all button.

17
00:00:52.960 --> 00:00:55.479
<v Speaker 1>You'll learn how to set up an AI stage with

18
00:00:55.560 --> 00:01:00.320
<v Speaker 1>custom approval logic, add targeted human reviews, design, dynamic condisitions

19
00:01:00.359 --> 00:01:04.640
<v Speaker 1>that reroot intelligently and integrate real document validation for compliance.

20
00:01:05.120 --> 00:01:07.200
<v Speaker 1>By the end, you'll have an automated process that knows

21
00:01:07.200 --> 00:01:08.959
<v Speaker 1>when to think like a machine and when to defer

22
00:01:09.000 --> 00:01:12.480
<v Speaker 1>to human judgment. Stop following a queue, start letting logic lead.

23
00:01:13.120 --> 00:01:16.840
<v Speaker 1>The problem with traditional approvals. Traditional approval chains are a

24
00:01:16.879 --> 00:01:20.120
<v Speaker 1>tragic remix of the same inefficiency. Someone submits a form,

25
00:01:20.400 --> 00:01:24.439
<v Speaker 1>emails fly, spreadsheets drift out of sync, and between forwarding loops,

26
00:01:24.480 --> 00:01:27.640
<v Speaker 1>nobody remembers which version was final. Each participant adds delay,

27
00:01:27.799 --> 00:01:31.040
<v Speaker 1>not value. The process doesn't manage the work, it manufactures

28
00:01:31.120 --> 00:01:34.959
<v Speaker 1>latency typical power automate approval flows try to solve this,

29
00:01:35.359 --> 00:01:38.519
<v Speaker 1>but they stall once you introduce nuance. A single approval

30
00:01:38.599 --> 00:01:40.840
<v Speaker 1>path works fine if you only need one yes or no.

31
00:01:41.439 --> 00:01:45.359
<v Speaker 1>The moment you add management layers, spending thresholds, or specialized rules,

32
00:01:45.359 --> 00:01:47.879
<v Speaker 1>the design begins to splinter. You end up nesting conditions

33
00:01:47.920 --> 00:01:51.079
<v Speaker 1>like Russian dolls, inelegant, fragile, and impossible to debug. Six

34
00:01:51.120 --> 00:01:54.879
<v Speaker 1>months later, one broken connector and the entire system silently fails.

35
00:01:55.239 --> 00:01:58.640
<v Speaker 1>Humans become the bottlenecks, or, to be brutally accurate, latency

36
00:01:58.680 --> 00:02:03.040
<v Speaker 1>notes every message They receive becomes another asynchronous round trip email.

37
00:02:03.079 --> 00:02:05.640
<v Speaker 1>As an approval mechanism is like using carrier pigeons in

38
00:02:05.640 --> 00:02:08.319
<v Speaker 1>a fiber optic world. It technically works, but it shouldn't.

39
00:02:08.639 --> 00:02:11.960
<v Speaker 1>Anti Microsoft Copilot Studio, this is not just an incremental

40
00:02:12.039 --> 00:02:16.080
<v Speaker 1>version of power Automate. It introduces agent flows approval systems

41
00:02:16.120 --> 00:02:20.919
<v Speaker 1>powered by AI, yet fully integrated into your organizations data sources, roles,

42
00:02:20.919 --> 00:02:25.000
<v Speaker 1>and logic structures. It bridges deterministic policy enforcement with adaptive

43
00:02:25.039 --> 00:02:28.639
<v Speaker 1>decision making. The brilliance lies in how it separates stages

44
00:02:29.039 --> 00:02:32.919
<v Speaker 1>automated where you want speed, human where you still require validation.

45
00:02:33.120 --> 00:02:35.800
<v Speaker 1>Think of it as hierarchy re engineered. The AI stage

46
00:02:35.800 --> 00:02:40.039
<v Speaker 1>evaluates fixed rules, amount limits, category types, date ranges with

47
00:02:40.159 --> 00:02:43.599
<v Speaker 1>clinical efficiency. Then if a decision teters on ambiguity, the

48
00:02:43.639 --> 00:02:47.039
<v Speaker 1>process escalates to human oversight without forcing every trivial case

49
00:02:47.080 --> 00:02:50.400
<v Speaker 1>to queue up. This alone eliminates exponential delay. Instead of

50
00:02:50.439 --> 00:02:54.000
<v Speaker 1>ten people performing serial reviews, AI handles eighty percent instantly,

51
00:02:54.120 --> 00:02:58.199
<v Speaker 1>routing only outliers and Yes, Copilot Studio tracks everything through

52
00:02:58.240 --> 00:03:01.639
<v Speaker 1>its data verse backbone, producing verifiable logs without your team

53
00:03:01.840 --> 00:03:05.240
<v Speaker 1>needing to dig through mailbox archives. Previous workflows were built

54
00:03:05.280 --> 00:03:08.319
<v Speaker 1>for humans. Agent flows are built around them, keeping people

55
00:03:08.319 --> 00:03:11.240
<v Speaker 1>in the loop only when interpretation not repetition, is required.

56
00:03:11.360 --> 00:03:14.159
<v Speaker 1>Once you see how this architecture functions, traditional approvals will

57
00:03:14.159 --> 00:03:19.360
<v Speaker 1>feel primitive, like balancing checkbooks by candlelight. The stakes are simple, compliance, consistency,

58
00:03:19.400 --> 00:03:23.479
<v Speaker 1>and scale. Modern operations drown without automated validation, and AI

59
00:03:23.520 --> 00:03:26.319
<v Speaker 1>assisted logic is now the baseline for reliability. When you

60
00:03:26.360 --> 00:03:29.840
<v Speaker 1>migrate from static flows to conditional, auditable agent flows, you

61
00:03:29.919 --> 00:03:33.879
<v Speaker 1>stop managing approvals reactively and start treating them as living systems.

62
00:03:34.199 --> 00:03:38.120
<v Speaker 1>The difference is not just speed, its structural sanity. Building

63
00:03:38.120 --> 00:03:41.439
<v Speaker 1>the AI stage, teaching the first approver now comes the

64
00:03:41.479 --> 00:03:45.360
<v Speaker 1>interesting part. Training your first digital bureaucrat the AI stage

65
00:03:45.400 --> 00:03:48.360
<v Speaker 1>is the logical gatekeeper of your approval process. Its job

66
00:03:48.400 --> 00:03:50.240
<v Speaker 1>is not to think like a human, but to perform

67
00:03:50.280 --> 00:03:54.360
<v Speaker 1>structured reasoning at superhuman consistency. It reads instructions, checks them

68
00:03:54.360 --> 00:03:57.919
<v Speaker 1>against inputs, and outputs one of two verdicts approved or rejected.

69
00:03:58.080 --> 00:04:01.039
<v Speaker 1>No politics, no coffee breaks. You begin by defining a

70
00:04:01.080 --> 00:04:03.719
<v Speaker 1>new agent flow. At creation, the AI stage sits front

71
00:04:03.759 --> 00:04:06.199
<v Speaker 1>and center, like an empty exam paper, waiting for its

72
00:04:06.280 --> 00:04:08.960
<v Speaker 1>question key. The trigger usually comes from data verse, a

73
00:04:09.000 --> 00:04:11.520
<v Speaker 1>record added or modified in your claims or expense table.

74
00:04:11.599 --> 00:04:15.039
<v Speaker 1>Once a claim is created, this stage activates, evaluates the data,

75
00:04:15.080 --> 00:04:18.240
<v Speaker 1>and decides accordingly. Inside the stage, the most important field

76
00:04:18.279 --> 00:04:20.959
<v Speaker 1>is the instruction prompt, the brain of the operation. This

77
00:04:21.000 --> 00:04:23.319
<v Speaker 1>is where you describe the approval logic in plain but

78
00:04:23.399 --> 00:04:26.160
<v Speaker 1>rigorous language. Write it as if you're instructing a lawyer

79
00:04:26.160 --> 00:04:29.879
<v Speaker 1>who never improvises. For example, approve the claim if the

80
00:04:29.920 --> 00:04:33.000
<v Speaker 1>amount is less than five hundred, the description supports physical

81
00:04:33.079 --> 00:04:35.439
<v Speaker 1>or mental health, and the purchase date is within thirty

82
00:04:35.519 --> 00:04:38.600
<v Speaker 1>days of submission. Reject if any rule fails, that's it

83
00:04:38.759 --> 00:04:42.720
<v Speaker 1>binary clarity. Next, define your dynamic inputs. Think of them

84
00:04:42.720 --> 00:04:45.600
<v Speaker 1>as variables, feeding real data into your logic. You'll most

85
00:04:45.639 --> 00:04:48.240
<v Speaker 1>likely include an amount, a description, and a purchase date.

86
00:04:48.560 --> 00:04:52.519
<v Speaker 1>Each is added as content, text, or number inputs that

87
00:04:52.600 --> 00:04:55.920
<v Speaker 1>the AI will pass when making a decision. Copilot Studio

88
00:04:56.000 --> 00:04:59.519
<v Speaker 1>classes these inputs by type text, number or image. Document.

89
00:04:59.720 --> 00:05:03.360
<v Speaker 1>Choose correctly because mixing types, say a number stored as

90
00:05:03.439 --> 00:05:07.279
<v Speaker 1>text confuses both humans and machines. Beneath each input, provide

91
00:05:07.279 --> 00:05:10.120
<v Speaker 1>sample data for testing. This acts as scaffolding while you

92
00:05:10.160 --> 00:05:13.319
<v Speaker 1>calibrate logic. For instance, enter an example claim like fitness

93
00:05:13.399 --> 00:05:17.040
<v Speaker 1>yoga mat amount three hundred, purchase date August twenty second.

94
00:05:17.439 --> 00:05:20.839
<v Speaker 1>When you hit test copilot, studio runs the reasoning model

95
00:05:21.079 --> 00:05:24.000
<v Speaker 1>GPT based under the hood, and outputs the decision plus

96
00:05:24.000 --> 00:05:28.160
<v Speaker 1>an explanation. If the outcome matches your expectation, good. If not,

97
00:05:28.680 --> 00:05:32.439
<v Speaker 1>your instructions lack determinism, and that's where most beginners mess up.

98
00:05:32.639 --> 00:05:38.160
<v Speaker 1>Broad or ambiguous phrasing. Reasonable expense, recent purchase is AI poison.

99
00:05:38.399 --> 00:05:41.759
<v Speaker 1>The system can't read corporate mood. It needs mathematical definitions,

100
00:05:41.839 --> 00:05:45.319
<v Speaker 1>So refine your instructions relentlessly until the test results are consistent.

101
00:05:45.439 --> 00:05:48.839
<v Speaker 1>Every time you reword, you're tuning the judgment engine for reproducibility.

102
00:05:49.240 --> 00:05:52.399
<v Speaker 1>The pattern you want is identical input producing identical output

103
00:05:52.480 --> 00:05:56.000
<v Speaker 1>every time, machine logic, not office gossip. Once your PROMPT

104
00:05:56.079 --> 00:05:59.639
<v Speaker 1>yields reliable decisions across multiple test cases, you've effectively trained

105
00:05:59.639 --> 00:06:03.040
<v Speaker 1>your AA approver. Now inject the real dynamic data using

106
00:06:03.079 --> 00:06:06.240
<v Speaker 1>tokens pulled from data verse claim amount details, purchase or

107
00:06:06.240 --> 00:06:09.360
<v Speaker 1>submission date. These replace your test values during live runs.

108
00:06:09.759 --> 00:06:13.000
<v Speaker 1>From that point on, the AI evaluates each claim in context,

109
00:06:13.199 --> 00:06:16.439
<v Speaker 1>returning an approval verdict the moment new data appears, before

110
00:06:16.439 --> 00:06:20.120
<v Speaker 1>declaring victory run iterative tests. Change the amount to six hundred,

111
00:06:20.160 --> 00:06:22.199
<v Speaker 1>does it reject? Change the date to three months ago?

112
00:06:22.279 --> 00:06:24.680
<v Speaker 1>Does it flagg as invalid? Add a nonsensical claim like

113
00:06:24.720 --> 00:06:27.839
<v Speaker 1>iPad purchase. Does it detect the mismatch? Each pass should

114
00:06:27.879 --> 00:06:31.639
<v Speaker 1>demonstrate consistent cause and effect. If responses fluctuate, the issue

115
00:06:31.680 --> 00:06:34.800
<v Speaker 1>is your prompt clarity, not the AI model. When consistent

116
00:06:34.800 --> 00:06:38.519
<v Speaker 1>patterns emerge, establish a naming convention for your content variables

117
00:06:38.680 --> 00:06:41.839
<v Speaker 1>prefixes like starclaim amount for strings or nun purchase date

118
00:06:41.879 --> 00:06:45.519
<v Speaker 1>for numeric values. This tiny discipline prevents chaos when you

119
00:06:45.560 --> 00:06:49.040
<v Speaker 1>expand later into multi branch logic. At this stage, your

120
00:06:49.079 --> 00:06:52.639
<v Speaker 1>automated approver can now make independent decisions based on policy

121
00:06:52.680 --> 00:06:56.879
<v Speaker 1>without supervision. But automation isn't dictatorship, its delegation. The machine

122
00:06:56.920 --> 00:07:00.519
<v Speaker 1>handles speed and precision, not judgment. For borderline scenario, you'll

123
00:07:00.519 --> 00:07:02.959
<v Speaker 1>need escalation a human in the loop to review what

124
00:07:03.040 --> 00:07:06.079
<v Speaker 1>the AI declines or deems uncertain. That's where the next

125
00:07:06.079 --> 00:07:08.600
<v Speaker 1>stage comes into play, and that's how authority gets shared

126
00:07:08.639 --> 00:07:12.639
<v Speaker 1>between silicon and staff, adding human oversight multi stage and

127
00:07:12.639 --> 00:07:16.279
<v Speaker 1>conditional logic. Once your AI stage is confidently judging claims,

128
00:07:16.279 --> 00:07:19.240
<v Speaker 1>you can add what bureaucracies ironically call the human touch

129
00:07:19.560 --> 00:07:23.000
<v Speaker 1>in copalate studio. That means a manual stage, a checkpoint

130
00:07:23.000 --> 00:07:25.680
<v Speaker 1>where a real person gets to exercise discretion. Think of

131
00:07:25.720 --> 00:07:29.720
<v Speaker 1>it as your safety valve. Everything predictable flows past automatically.

132
00:07:30.199 --> 00:07:33.079
<v Speaker 1>Anything nuanced lands on a manager's desk. You start in

133
00:07:33.120 --> 00:07:35.680
<v Speaker 1>the approval designer by adding a manual stage right after

134
00:07:35.720 --> 00:07:38.199
<v Speaker 1>the AI one. This creates a second gait in your

135
00:07:38.240 --> 00:07:41.160
<v Speaker 1>agent flow. The handoff is conditional only if the AIS

136
00:07:41.199 --> 00:07:44.279
<v Speaker 1>verdict equals approved, do we proceed to the human stage.

137
00:07:44.319 --> 00:07:46.879
<v Speaker 1>If the AIS has rejected, the process ends right there.

138
00:07:47.000 --> 00:07:50.600
<v Speaker 1>Why waste time asking managers to confirm what policy already disqualified?

139
00:07:51.000 --> 00:07:54.519
<v Speaker 1>Efficiency is selective attention dressed as automation. Let's set up

140
00:07:54.519 --> 00:07:57.519
<v Speaker 1>an example scenarios. Suppose an employee submits an expense claim

141
00:07:57.519 --> 00:08:00.720
<v Speaker 1>for gym membership. The AI approves it because all criteria

142
00:08:00.759 --> 00:08:04.000
<v Speaker 1>fit the policy. Now that decision triggers a manager level

143
00:08:04.000 --> 00:08:07.720
<v Speaker 1>manual stage called manager approval. Under the hood, you configure

144
00:08:07.759 --> 00:08:10.839
<v Speaker 1>this stage with a title like claim approval Request from

145
00:08:11.079 --> 00:08:14.839
<v Speaker 1>Claim submitter. Those variables pull data dynamically from data verse.

146
00:08:15.279 --> 00:08:17.839
<v Speaker 1>The assigned to field is where you define who receives

147
00:08:17.879 --> 00:08:21.639
<v Speaker 1>the task, typically the claimant's manager. To automate this routing,

148
00:08:21.720 --> 00:08:24.480
<v Speaker 1>copilot studio lets you integrate the office three sixty five

149
00:08:24.639 --> 00:08:28.120
<v Speaker 1>users connector. First grab the user record of whoever created

150
00:08:28.120 --> 00:08:30.600
<v Speaker 1>the claim using the get row by ID action on

151
00:08:30.639 --> 00:08:34.519
<v Speaker 1>the user table in data verse that retrieves the submitter's information. Next,

152
00:08:34.559 --> 00:08:37.279
<v Speaker 1>the get manager action fetches that users manager via their

153
00:08:37.279 --> 00:08:40.440
<v Speaker 1>primary email. Pass that result back into your manual stage

154
00:08:40.440 --> 00:08:43.879
<v Speaker 1>as a variable like estair manager email result. No hard coding,

155
00:08:43.919 --> 00:08:48.759
<v Speaker 1>no stale hierarchies, managers change, hierarchy refreshes itself, now comes

156
00:08:48.799 --> 00:08:52.240
<v Speaker 1>conditional branching, the real reason multi stage approvals exist. You

157
00:08:52.240 --> 00:08:55.279
<v Speaker 1>can introduce logic directly inside the agent flow. If claim

158
00:08:55.279 --> 00:08:57.600
<v Speaker 1>amount is greater then or equal to one hundred and fifty,

159
00:08:57.799 --> 00:09:00.679
<v Speaker 1>then add an additional stage for admin approval, otherwise end

160
00:09:00.759 --> 00:09:03.960
<v Speaker 1>the process. As this turns a simple two step routine

161
00:09:04.080 --> 00:09:06.720
<v Speaker 1>into a multi tiered decision tree that adapts to context.

162
00:09:07.080 --> 00:09:10.159
<v Speaker 1>Low value claims get one human, higher value or risky

163
00:09:10.159 --> 00:09:13.279
<v Speaker 1>claims escalate for extra eyes in the designer. Insert a

164
00:09:13.279 --> 00:09:16.600
<v Speaker 1>condition action before closing the flow. Reference your numeric variable,

165
00:09:16.639 --> 00:09:20.639
<v Speaker 1>perhaps numb claim amount, choose the operator greater than or

166
00:09:20.679 --> 00:09:23.679
<v Speaker 1>equal to, and set the threshold, such as one hundred

167
00:09:23.639 --> 00:09:26.279
<v Speaker 1>and fifty in the if true branch. At another manual

168
00:09:26.279 --> 00:09:29.120
<v Speaker 1>stage named admin approval, assign it to a fixed approver

169
00:09:29.279 --> 00:09:32.039
<v Speaker 1>like the compliance administrator in the if false branch, and

170
00:09:32.120 --> 00:09:35.360
<v Speaker 1>as approved. The effect the workflow behaves like a rational

171
00:09:35.440 --> 00:09:39.080
<v Speaker 1>organization instead of a universal bottleneck. A bit of practical

172
00:09:39.159 --> 00:09:43.120
<v Speaker 1>humor applies here. Yes, delegation still requires trust, not wishful routing.

173
00:09:43.360 --> 00:09:46.799
<v Speaker 1>Don't assign broad security roles that can approve everything. Restrict

174
00:09:46.799 --> 00:09:49.799
<v Speaker 1>permissions to relevant users or groups through data verse role

175
00:09:49.799 --> 00:09:53.639
<v Speaker 1>based access control. Otherwise you've automated anarchy. Testing this structure

176
00:09:53.639 --> 00:09:56.600
<v Speaker 1>reveals how smoothly each piece fits. When a claim under

177
00:09:56.600 --> 00:09:59.279
<v Speaker 1>one hundred and fifty dollars passes AI review, the flow

178
00:09:59.399 --> 00:10:01.960
<v Speaker 1>ends after manl Man approval. When over one hundred and

179
00:10:02.000 --> 00:10:04.799
<v Speaker 1>fifty dollars, the system politely accues it for ADMIN review

180
00:10:04.799 --> 00:10:08.320
<v Speaker 1>before finalizing. Each path leaves an audit trail, the AI

181
00:10:08.480 --> 00:10:11.480
<v Speaker 1>reasoning log time stamped approvals and recorded outcomes stored in

182
00:10:11.559 --> 00:10:13.960
<v Speaker 1>data verse. No one can later claim I never saw it,

183
00:10:14.480 --> 00:10:17.720
<v Speaker 1>the database says. Otherwise, as you refine, keep naming conventions,

184
00:10:17.720 --> 00:10:23.080
<v Speaker 1>disciplined prefix human stages, clearly man approved admin approved, so

185
00:10:23.120 --> 00:10:25.960
<v Speaker 1>you can trace branches visually. The flow chart should read

186
00:10:26.039 --> 00:10:29.759
<v Speaker 1>like logic, not mystery art. Once satisfied, publish and test

187
00:10:29.799 --> 00:10:33.840
<v Speaker 1>with real scenarios. Watch the chain unfold. AI evaluates instantly,

188
00:10:34.200 --> 00:10:37.840
<v Speaker 1>manager gets a targeted approval, task edmin joins only when

189
00:10:37.879 --> 00:10:41.639
<v Speaker 1>conditions warrant. The result feels less like automation doing everything

190
00:10:41.679 --> 00:10:45.399
<v Speaker 1>and more like a transparent hierarchy that handles itself. This

191
00:10:45.519 --> 00:10:49.919
<v Speaker 1>layered orchestration also exposes a new frontier document validation, because

192
00:10:49.919 --> 00:10:52.639
<v Speaker 1>sometimes a form field lies but the receipt doesn't. The

193
00:10:52.679 --> 00:10:55.159
<v Speaker 1>next step is to make the AI examine the physical

194
00:10:55.159 --> 00:10:57.919
<v Speaker 1>evidence before it ever reaches your inbox. That's where receipt

195
00:10:58.000 --> 00:11:02.559
<v Speaker 1>validation enters, turning bureaucracy into verifiable science, dynamic inputs and

196
00:11:02.559 --> 00:11:06.039
<v Speaker 1>document validation. Let's talk about receipts, the tiny crumpled pieces

197
00:11:06.039 --> 00:11:09.759
<v Speaker 1>of paper that mysteriously become critical evidence once someone wants reimbursement.

198
00:11:10.320 --> 00:11:14.360
<v Speaker 1>In a manual approval process, humans verify them by eyeballing yes,

199
00:11:14.399 --> 00:11:16.559
<v Speaker 1>that looks like a yoga mat, not a yacht. In

200
00:11:16.600 --> 00:11:18.919
<v Speaker 1>an automated one, we make the AI perform the same

201
00:11:19.039 --> 00:11:23.240
<v Speaker 1>check without judgment fatigue. In copilot studios, agent flows document

202
00:11:23.320 --> 00:11:26.840
<v Speaker 1>validation comes to life through dynamic content inputs, specifically the

203
00:11:26.879 --> 00:11:29.759
<v Speaker 1>ability to pass an image or file into your approval logic.

204
00:11:29.919 --> 00:11:32.320
<v Speaker 1>This adds a third sense to your AI approver side.

205
00:11:32.639 --> 00:11:35.320
<v Speaker 1>Instead of relying solely on text fields, the model reads

206
00:11:35.320 --> 00:11:38.039
<v Speaker 1>the document and compares what's written against what was uploaded.

207
00:11:38.279 --> 00:11:41.519
<v Speaker 1>Here's the structure inside your AI stage. You add a

208
00:11:41.519 --> 00:11:44.840
<v Speaker 1>new input type called image or document. Label it clearly

209
00:11:45.039 --> 00:11:48.320
<v Speaker 1>something like dock, receid file upload a sample receipt for testing.

210
00:11:48.480 --> 00:11:51.080
<v Speaker 1>This doesn't go live, it just trains the logic layout.

211
00:11:51.279 --> 00:11:54.639
<v Speaker 1>Now adjust your instruction prompt to include document cross validation.

212
00:11:55.000 --> 00:11:57.639
<v Speaker 1>You extend your previous logic approve the claim if all

213
00:11:57.679 --> 00:12:00.399
<v Speaker 1>the following are true. Amount five hundred, claim detail support

214
00:12:00.399 --> 00:12:02.759
<v Speaker 1>physical or mental health purchas, date within thirty days, and

215
00:12:02.799 --> 00:12:05.600
<v Speaker 1>the receipt document matches the declared item amount and date.

216
00:12:06.159 --> 00:12:09.720
<v Speaker 1>This fourth condition transforms your AI approver from policy enforcer

217
00:12:09.759 --> 00:12:13.440
<v Speaker 1>into forensic accountant. When the test runs, the model extracts

218
00:12:13.519 --> 00:12:16.799
<v Speaker 1>readable text from the document and verifies consistency with your

219
00:12:16.840 --> 00:12:20.399
<v Speaker 1>structured inputs. If the receipt lists fitness mat three hundred

220
00:12:20.399 --> 00:12:23.279
<v Speaker 1>dollars August twenty seven, and your claim says anything else,

221
00:12:23.600 --> 00:12:26.399
<v Speaker 1>the verdict flips to reject it. Now for implementation, before

222
00:12:26.440 --> 00:12:29.200
<v Speaker 1>the approval runs, you'll need to fetch that document. Use

223
00:12:29.240 --> 00:12:31.600
<v Speaker 1>the download a file or image action from data verse

224
00:12:32.039 --> 00:12:34.679
<v Speaker 1>target the same table the claim record resides in likely

225
00:12:34.720 --> 00:12:38.360
<v Speaker 1>claims under file column. Choose the attachment field often named

226
00:12:38.360 --> 00:12:42.840
<v Speaker 1>something like receipt, then specify the row id dynamically from

227
00:12:42.840 --> 00:12:46.240
<v Speaker 1>the trigger the unique claim identifier. This action returns file

228
00:12:46.320 --> 00:12:49.240
<v Speaker 1>meta data and content. But here's the subtle trap. The

229
00:12:49.399 --> 00:12:53.120
<v Speaker 1>content output needs slight surgery for the AI to interpret correctly.

230
00:12:53.279 --> 00:12:56.120
<v Speaker 1>When mapping the file content into your dock receipt file input,

231
00:12:56.360 --> 00:12:59.600
<v Speaker 1>open the expression editor and append content to the body

232
00:12:59.639 --> 00:13:03.200
<v Speaker 1>reference that last week delivers the actual file bites rather

233
00:13:03.240 --> 00:13:05.799
<v Speaker 1>than the metadata wrapper. Skip it and your AI will

234
00:13:05.879 --> 00:13:10.399
<v Speaker 1>enthusiastically approve blank receipts. Let's address synchronization, the achilles heel

235
00:13:10.399 --> 00:13:13.840
<v Speaker 1>of document workflows. Most data verse tables don't store attachments

236
00:13:13.919 --> 00:13:17.360
<v Speaker 1>until after the record first saves, meaning if your flow

237
00:13:17.399 --> 00:13:19.960
<v Speaker 1>triggers on record creation, it may fire before the file

238
00:13:20.039 --> 00:13:23.919
<v Speaker 1>exists symptom flow fails, or the receipt content is null.

239
00:13:24.039 --> 00:13:26.759
<v Speaker 1>The remedy is elegant. Change the trigger condition to on

240
00:13:26.840 --> 00:13:30.360
<v Speaker 1>item modification but restricted to fire only when the receipt

241
00:13:30.360 --> 00:13:33.960
<v Speaker 1>column changes that way. The moment someone uploads or replaces

242
00:13:33.960 --> 00:13:38.399
<v Speaker 1>a file, validation kicks in. To configure this, open trigger settings,

243
00:13:38.639 --> 00:13:41.720
<v Speaker 1>choose modified columns and paste the logical name of your

244
00:13:41.720 --> 00:13:45.720
<v Speaker 1>receipt column retrievable from data verse column detail under advanced tools.

245
00:13:46.279 --> 00:13:50.600
<v Speaker 1>Once set publish now, your automation behaves politely. It waits

246
00:13:50.679 --> 00:13:53.799
<v Speaker 1>until there's actually something to validate. When the claim updates

247
00:13:53.799 --> 00:13:56.720
<v Speaker 1>with a new receipt, the flow restarts. It downloads the file,

248
00:13:56.919 --> 00:14:00.639
<v Speaker 1>feeds it through the AI stage, and cross checks all inputs.

249
00:14:01.039 --> 00:14:06.000
<v Speaker 1>If discrepancies exist amount mismatch, outdated date, inconsistent descriptions, the

250
00:14:06.080 --> 00:14:09.679
<v Speaker 1>AI rejects with explanation included. The reasoning blog might read

251
00:14:09.879 --> 00:14:12.440
<v Speaker 1>claimed amound three hundred five dollars differs from document total

252
00:14:12.480 --> 00:14:15.960
<v Speaker 1>three hundred dollars. That's compliance without complaint. The practical impact

253
00:14:16.240 --> 00:14:19.519
<v Speaker 1>every submission becomes self auditing. Employees can no longer slip

254
00:14:19.519 --> 00:14:23.759
<v Speaker 1>through questionable receipts or vague descriptions. AI provides the judgment,

255
00:14:24.000 --> 00:14:27.200
<v Speaker 1>data Verse provides the evidence, and neither takes coffee breaks,

256
00:14:27.559 --> 00:14:31.320
<v Speaker 1>so no document validation isn't overkill. It's immune memory for

257
00:14:31.360 --> 00:14:34.960
<v Speaker 1>your workflows. Outliers get caught at the molecular level, the

258
00:14:35.039 --> 00:14:38.200
<v Speaker 1>characters printed on actual receipts, and the human reviewer gets

259
00:14:38.200 --> 00:14:41.759
<v Speaker 1>promoted from manual checker to exception handler. Congratulations, you've now

260
00:14:41.840 --> 00:14:48.039
<v Speaker 1>automated honesty itself, building reliability, testing, versioning, and publishing. Any

261
00:14:48.080 --> 00:14:51.679
<v Speaker 1>automation can look perfect until it runs. That's why reliability

262
00:14:51.720 --> 00:14:54.240
<v Speaker 1>is not a phase, It's a discipline. Copilot Studio makes

263
00:14:54.240 --> 00:14:57.960
<v Speaker 1>that discipline surprisingly civilized through versioning, testing, and publishing controls

264
00:14:58.000 --> 00:15:02.120
<v Speaker 1>embedded directly into agent flows. Start with iterative testing. Every

265
00:15:02.120 --> 00:15:05.480
<v Speaker 1>approval flow is a miniature ecosystem. Even one stray variable

266
00:15:05.559 --> 00:15:09.679
<v Speaker 1>name can create chaos, so treat testing as a scientific process.

267
00:15:10.000 --> 00:15:14.039
<v Speaker 1>Isolate changes, apply data, observe output in the flow editor.

268
00:15:14.159 --> 00:15:18.360
<v Speaker 1>Copalot Studio lets you simulate sample data without deploying production triggers.

269
00:15:18.480 --> 00:15:23.440
<v Speaker 1>Feed variant scenarios two large amount outdated, date irrelevant item names,

270
00:15:23.600 --> 00:15:26.360
<v Speaker 1>and ensure each yields the correct verdict. Then move to

271
00:15:26.440 --> 00:15:31.039
<v Speaker 1>naming conventions. Boring absolutely essential more than air prefix Every

272
00:15:31.120 --> 00:15:35.759
<v Speaker 1>variable systematically sdr for strings, non pH numerics, dock for files. Likewise,

273
00:15:35.879 --> 00:15:40.120
<v Speaker 1>label actions explicitly download receipt file check manager, approval update

274
00:15:40.120 --> 00:15:42.679
<v Speaker 1>claim approved, because in three months, when someone asks why

275
00:15:42.799 --> 00:15:46.679
<v Speaker 1>Action seven broke, you'll appreciate that breadcrumbs are friendlier than archaeology.

276
00:15:46.960 --> 00:15:50.919
<v Speaker 1>Once individual tests succeed, expand to edge scenario validation. Pretend

277
00:15:50.960 --> 00:15:54.080
<v Speaker 1>to be the incompetent user, upload no receipt, change a

278
00:15:54.159 --> 00:15:57.120
<v Speaker 1>date to next year, type five hundred instead of five hundred.

279
00:15:57.480 --> 00:16:01.039
<v Speaker 1>Confirm the AI explains and rejects without crash. These aren't

280
00:16:01.080 --> 00:16:04.679
<v Speaker 1>hypothetical screw ups, their reality rehearsals. The more failure cases

281
00:16:04.759 --> 00:16:07.799
<v Speaker 1>you neutralize upfront, the fewer two AM team's messages you'll

282
00:16:07.799 --> 00:16:11.879
<v Speaker 1>get later saying the flow stopped again. Publishing introduces governance.

283
00:16:12.559 --> 00:16:15.320
<v Speaker 1>Each time you save a major change, co pilot studio

284
00:16:15.440 --> 00:16:17.919
<v Speaker 1>quietly creates a new version you can revert any time,

285
00:16:18.080 --> 00:16:22.000
<v Speaker 1>no overright anxiety. Use this to keep experimental logic sandboxes

286
00:16:22.039 --> 00:16:25.720
<v Speaker 1>apart from production. One flow named claim approval DEV, another

287
00:16:25.759 --> 00:16:29.919
<v Speaker 1>Claim approval PROD test in DEV. Publish only when stable. Remember,

288
00:16:29.919 --> 00:16:34.919
<v Speaker 1>reliability isn't just about correctness, it's about control under change.

289
00:16:35.039 --> 00:16:38.799
<v Speaker 1>After publishing, leverage the activity logs. They're not decorative. They're

290
00:16:38.840 --> 00:16:42.519
<v Speaker 1>legal grade records of AI and human interactions. Time stamps,

291
00:16:42.559 --> 00:16:47.679
<v Speaker 1>approver identities, reasoning summaries review these logs periodically. Patterns reveal themselves,

292
00:16:47.919 --> 00:16:51.480
<v Speaker 1>which rules trigger most rejections, which managers overrule the AI

293
00:16:51.879 --> 00:16:55.519
<v Speaker 1>how often compliance steps engage Those insights refine both policy

294
00:16:55.559 --> 00:16:59.840
<v Speaker 1>and design. Another subtle best practice automated status updates back

295
00:16:59.879 --> 00:17:02.080
<v Speaker 1>in to data verse records at the end of each branch.

296
00:17:02.200 --> 00:17:04.599
<v Speaker 1>The update a row action should set a clear field

297
00:17:04.720 --> 00:17:08.599
<v Speaker 1>like claim status exlors approved or rejected. This visible endpoint

298
00:17:08.599 --> 00:17:12.000
<v Speaker 1>reinforces trust. Users see decisions inside their own table views.

299
00:17:12.319 --> 00:17:15.680
<v Speaker 1>No separate tracking spreadsheet, no phantom approvals. Once your system

300
00:17:15.680 --> 00:17:19.000
<v Speaker 1>passes all tests hit published with quiet confidence. Unlike earlier

301
00:17:19.039 --> 00:17:23.000
<v Speaker 1>generations of power automate flows, agent flows retain contextual metadata,

302
00:17:23.319 --> 00:17:27.160
<v Speaker 1>the AI decision schema, dynamic content bindings, and version tags.

303
00:17:27.559 --> 00:17:29.559
<v Speaker 1>The result is not just a running process, but a

304
00:17:29.599 --> 00:17:34.720
<v Speaker 1>reproducible artifact auditable automation. The final reliability check is mental

305
00:17:34.839 --> 00:17:38.599
<v Speaker 1>resist over engineering. Sometimes a failed flow reveals over complex rules,

306
00:17:38.599 --> 00:17:43.640
<v Speaker 1>not technical bugs, streamline logic where possible, fewer stages, clearer instructions,

307
00:17:43.720 --> 00:17:49.799
<v Speaker 1>minimal ambiguity. Automation's enemy isn't randomness, its unnecessary cleverness. When

308
00:17:49.799 --> 00:17:53.599
<v Speaker 1>you finish this stage, your approval system achieves operational maturity, tested,

309
00:17:53.759 --> 00:17:57.839
<v Speaker 1>version rowback, friendly and verifiable. Every outcome from AI judgment

310
00:17:57.880 --> 00:18:00.279
<v Speaker 1>to admin sign off leaves a digital footprint that's stands

311
00:18:00.319 --> 00:18:03.640
<v Speaker 1>up to scrutiny. That's reliability quantified, not a vibe, not luck,

312
00:18:03.960 --> 00:18:07.279
<v Speaker 1>just structured reasoning recorded faithfully by the tools you build

313
00:18:07.359 --> 00:18:10.759
<v Speaker 1>to think while you sleep, results in real world payoff.

314
00:18:11.000 --> 00:18:13.920
<v Speaker 1>What happens when you hand bureaucracy to mathematics. The approvals

315
00:18:13.920 --> 00:18:17.599
<v Speaker 1>stop waiting. An AI driven multi stage agent flow cuts

316
00:18:17.640 --> 00:18:20.200
<v Speaker 1>turn around from days to minutes. Because decisions no longer

317
00:18:20.200 --> 00:18:24.160
<v Speaker 1>depend on calendar availability. Every claim that meets objective policy

318
00:18:24.200 --> 00:18:27.279
<v Speaker 1>is approved instantly. Every edge case lands neatly in a

319
00:18:27.319 --> 00:18:31.519
<v Speaker 1>manager's queue with the context already attached. Humans make value judgments,

320
00:18:31.519 --> 00:18:35.160
<v Speaker 1>not clerical confirmations. The impact appears first as time compression.

321
00:18:35.440 --> 00:18:38.440
<v Speaker 1>A reimbursement that once required four emails and two reminders

322
00:18:38.440 --> 00:18:43.039
<v Speaker 1>now resolves before lunch. Departments experience shorter processing cycles, less

323
00:18:43.079 --> 00:18:46.960
<v Speaker 1>idle status, and perfectly logged reasoning trails. The approval mechanism

324
00:18:47.119 --> 00:18:51.559
<v Speaker 1>ceases to be an interruption. It becomes infrastructure. Then comes

325
00:18:51.680 --> 00:18:55.640
<v Speaker 1>error reduction. By enforcing deterministic rules through AI, you remove

326
00:18:55.680 --> 00:18:58.720
<v Speaker 1>subjective drift. The bane of manual approvals. No more I

327
00:18:58.720 --> 00:19:02.599
<v Speaker 1>thought discounted as health and wellness. The AI interprets criteria

328
00:19:02.640 --> 00:19:06.079
<v Speaker 1>the same way every time. Consistency scales better than compassion.

329
00:19:06.160 --> 00:19:09.400
<v Speaker 1>In administrative logic, managers deal only with anomalies, and even

330
00:19:09.440 --> 00:19:12.960
<v Speaker 1>those come with a full audit trail. Data inputs, decision history,

331
00:19:13.039 --> 00:19:17.240
<v Speaker 1>model explanation, audits transform from panic exercises into polite verifications.

332
00:19:17.559 --> 00:19:20.720
<v Speaker 1>On an organizational level, this isn't just faster, it's safer.

333
00:19:21.480 --> 00:19:24.720
<v Speaker 1>Compliance doesn't rely on memory or mood, it's embedded. The

334
00:19:24.799 --> 00:19:27.880
<v Speaker 1>data verse logs show who approved, when and why. That

335
00:19:27.960 --> 00:19:31.599
<v Speaker 1>transparency discourages short cut culture because every decision now lives

336
00:19:31.640 --> 00:19:35.559
<v Speaker 1>in searchable permanence and Philosophically, the workflow flips from human

337
00:19:35.559 --> 00:19:38.599
<v Speaker 1>first with AI assistance to AI first with human correction

338
00:19:38.920 --> 00:19:42.880
<v Speaker 1>practical governance not science fiction. AI handles rule enforcement, humans

339
00:19:42.880 --> 00:19:46.279
<v Speaker 1>handle judgment. The hybrid produces fairer, faster, and ultimately more

340
00:19:46.319 --> 00:19:49.599
<v Speaker 1>trustworthy systems. Imagine explaining that to an auditor the kind

341
00:19:49.599 --> 00:19:52.680
<v Speaker 1>of smile that follows is worth the automation alone. So

342
00:19:52.759 --> 00:19:56.160
<v Speaker 1>there it is. Microsoft Copilot Studio isn't just another automation tool.

343
00:19:56.319 --> 00:20:00.240
<v Speaker 1>It's the place where your organization's indecision finally retires. Built

344
00:20:00.240 --> 00:20:03.519
<v Speaker 1>an approval engine that can think in conditions, escalate, responsibly,

345
00:20:03.680 --> 00:20:07.000
<v Speaker 1>validate receipts against reality, and document every move it makes.

346
00:20:07.279 --> 00:20:09.400
<v Speaker 1>That's not a flow, it's a governance model. If you

347
00:20:09.440 --> 00:20:13.920
<v Speaker 1>remember nothing else, remember this AI should make decisions predictable

348
00:20:14.000 --> 00:20:17.519
<v Speaker 1>and humans exceptional. Stop roting everything through people out of habit.

349
00:20:17.839 --> 00:20:21.519
<v Speaker 1>Let logic handle the routine so managers can handle exceptions. Now,

350
00:20:21.599 --> 00:20:24.319
<v Speaker 1>if this walkthrough saved you from another week of pending

351
00:20:24.359 --> 00:20:28.240
<v Speaker 1>manager review, consider subscribing. The next tutorial dives deeper into

352
00:20:28.279 --> 00:20:31.920
<v Speaker 1>advanced copilot studio automations, where these agent flows connect with

353
00:20:32.000 --> 00:20:36.599
<v Speaker 1>power platform analytics and adaptive policies. Lock in your upgrade path, subscribe,

354
00:20:36.640 --> 00:20:39.440
<v Speaker 1>turn on alerts, and let new episodes deploy automatically. No

355
00:20:39.599 --> 00:20:43.519
<v Speaker 1>manual checks, no mist releases, just continuous delivery of useful knowledge.

356
00:20:43.559 --> 00:20:43.920
<v Speaker 1>Proceed