WEBVTT

1
00:00:00.080 --> 00:00:02.680
<v Speaker 1>You know that sinking feeling when your power pages form

2
00:00:02.680 --> 00:00:05.719
<v Speaker 1>won't validate and the error messages are about as useful

3
00:00:05.719 --> 00:00:08.039
<v Speaker 1>as a four h four brain not found. That pain

4
00:00:08.039 --> 00:00:10.640
<v Speaker 1>point is exactly what we'll fix today. We're covering five

5
00:00:10.720 --> 00:00:15.039
<v Speaker 1>moves streamlining liquid templates, speeding JavaScript and form validation, getting

6
00:00:15.080 --> 00:00:19.760
<v Speaker 1>plain English code explanations, integrating HTML with Bootstrap for responsive layouts,

7
00:00:19.960 --> 00:00:23.679
<v Speaker 1>and simplifying web api calls. One quick caveat, you'll need

8
00:00:23.760 --> 00:00:27.239
<v Speaker 1>vs code with the power Platform Tools extension, GitHub Copilot

9
00:00:27.320 --> 00:00:29.760
<v Speaker 1>chat and your side content pulled down through the power

10
00:00:29.800 --> 00:00:33.640
<v Speaker 1>Platform CLI with data verse authentication. That setup makes Copilot

11
00:00:33.640 --> 00:00:37.079
<v Speaker 1>context aware. With that in place, Copilot stops lobbing random snippets.

12
00:00:37.119 --> 00:00:40.000
<v Speaker 1>It gives contextual, iterative code that cuts down trial and error.

13
00:00:40.039 --> 00:00:42.280
<v Speaker 1>I'll show you the exact prompts so you can replicate

14
00:00:42.320 --> 00:00:46.159
<v Speaker 1>results yourself. And since most pain starts with JavaScript, let's

15
00:00:46.200 --> 00:00:48.359
<v Speaker 1>roll into what happens when your form errors feel like

16
00:00:48.359 --> 00:00:51.600
<v Speaker 1>a natural swan. When JavaScript feels like a natural one,

17
00:00:51.799 --> 00:00:54.359
<v Speaker 1>JavaScript can turn what should be a straightforward form check

18
00:00:54.359 --> 00:00:57.640
<v Speaker 1>into a disaster fast one misplaced keystroke, and instead of

19
00:00:57.640 --> 00:01:01.039
<v Speaker 1>stopping bad input, the whole flow collapse. That's usually when

20
00:01:01.079 --> 00:01:03.560
<v Speaker 1>you sit there staring at the screen, wondering how banana

21
00:01:03.560 --> 00:01:06.599
<v Speaker 1>ever got past your carefully written validation logic. You know

22
00:01:06.680 --> 00:01:09.120
<v Speaker 1>the drill, a form that looks harmless, a valid data

23
00:01:09.159 --> 00:01:11.959
<v Speaker 1>meant to filter nonsense, and a clever user typing the

24
00:01:11.959 --> 00:01:14.840
<v Speaker 1>one thing you didn't account for. Suddenly your console locks,

25
00:01:14.840 --> 00:01:17.280
<v Speaker 1>explode with complaints, and every vs code tap feels like

26
00:01:17.319 --> 00:01:20.799
<v Speaker 1>another dead end. The small errors hit the hardest, a

27
00:01:20.840 --> 00:01:23.760
<v Speaker 1>missing semicolon or a scope bug that makes sense in

28
00:01:23.799 --> 00:01:25.799
<v Speaker 1>your head but plays out like poison damage when the

29
00:01:25.840 --> 00:01:28.799
<v Speaker 1>code runs. These tiny slips show up in real deployments

30
00:01:28.840 --> 00:01:31.959
<v Speaker 1>all the time, and they explain why broken validation is

31
00:01:32.000 --> 00:01:35.239
<v Speaker 1>such a familiar ticket in web development. Normally, your approach

32
00:01:35.280 --> 00:01:38.319
<v Speaker 1>is brute force. You tweak a line, refresh, get kicked

33
00:01:38.359 --> 00:01:41.079
<v Speaker 1>back by another error, then repeat the cycle until something

34
00:01:41.120 --> 00:01:44.159
<v Speaker 1>finally sticks. An evening evaporates, and the end result is

35
00:01:44.159 --> 00:01:47.120
<v Speaker 1>often just a duct taped script that runs, no elegance,

36
00:01:47.159 --> 00:01:49.959
<v Speaker 1>no teaching moment. That's why debugging validation feels like the

37
00:01:49.959 --> 00:01:53.959
<v Speaker 1>classic natural one. You're rolling, but the outcome is stacked

38
00:01:53.959 --> 00:01:57.680
<v Speaker 1>against you. Here's where copilot comes in. Generic copilot suggestions

39
00:01:57.879 --> 00:01:59.719
<v Speaker 1>sometimes help, but a lot of the time they look

40
00:01:59.760 --> 00:02:02.359
<v Speaker 1>like random fragments pulled from a half remembered quest log.

41
00:02:02.599 --> 00:02:05.640
<v Speaker 1>Useful in spirit, wrong in detail. That's because Plin Copilot

42
00:02:05.640 --> 00:02:08.080
<v Speaker 1>doesn't know the quirks of power Pages. But add the

43
00:02:08.120 --> 00:02:11.080
<v Speaker 1>AD power Pages participant, and suddenly it's not spitting boilerplate.

44
00:02:11.159 --> 00:02:14.199
<v Speaker 1>It's offering context aware code shaped to fit your environment.

45
00:02:14.560 --> 00:02:17.840
<v Speaker 1>Microsoft built it to handle power Pages specifics, including liquid

46
00:02:17.879 --> 00:02:21.080
<v Speaker 1>templates and data verse bindings, which means the suggestions account

47
00:02:21.120 --> 00:02:23.639
<v Speaker 1>for the features that usually trip you up, and it's

48
00:02:23.639 --> 00:02:27.039
<v Speaker 1>not just about generating snippets. The AD power Pages integration

49
00:02:27.199 --> 00:02:30.520
<v Speaker 1>can also explain power Pages specific constructs, so you don't

50
00:02:30.560 --> 00:02:32.800
<v Speaker 1>just paste and prey. You actually understand why a script

51
00:02:32.800 --> 00:02:35.879
<v Speaker 1>does what it does. That makes debugging less like wandering

52
00:02:35.879 --> 00:02:39.159
<v Speaker 1>blindfolded and more like working alongside someone who already cleared

53
00:02:39.159 --> 00:02:41.680
<v Speaker 1>the same dungeon. For example, you can literally type this

54
00:02:41.759 --> 00:02:45.080
<v Speaker 1>prompt into copilot chat at power Pages right JavaScript code

55
00:02:45.080 --> 00:02:47.639
<v Speaker 1>for form field validation to verify the phone field value

56
00:02:47.639 --> 00:02:50.479
<v Speaker 1>is in the valid format. That's not just theory. That's

57
00:02:50.479 --> 00:02:53.960
<v Speaker 1>a reproducible, demo ready input you'll see later in this walkthrough.

58
00:02:54.039 --> 00:02:56.560
<v Speaker 1>The code that comes back isn't a vague web snippet.

59
00:02:56.759 --> 00:02:59.639
<v Speaker 1>It's directly applicable and designed to compile in your power

60
00:02:59.639 --> 00:03:03.719
<v Speaker 1>Pages context. That predictability is the real shift. With Generic Copilot,

61
00:03:03.800 --> 00:03:05.919
<v Speaker 1>it feels like you've pulled in a bard who might

62
00:03:05.960 --> 00:03:08.080
<v Speaker 1>strum the right cord. But half the time the tune

63
00:03:08.080 --> 00:03:10.000
<v Speaker 1>has nothing to do with your current battle. With ad

64
00:03:10.000 --> 00:03:12.159
<v Speaker 1>power Pages. It's closer to traveling with a ranger who

65
00:03:12.159 --> 00:03:14.800
<v Speaker 1>already knows where the pitfalls are hiding. The quest becomes

66
00:03:14.879 --> 00:03:18.439
<v Speaker 1>less about surviving traps and more about designing clear user experiences.

67
00:03:18.960 --> 00:03:21.439
<v Speaker 1>The tool doesn't replace your judgment, it sharpens it. You

68
00:03:21.479 --> 00:03:24.159
<v Speaker 1>still decide what counts as valid input and how error

69
00:03:24.199 --> 00:03:27.159
<v Speaker 1>should guide the user, but instead of burning cycles on

70
00:03:27.199 --> 00:03:30.280
<v Speaker 1>syntax bugs and booleant typos, you spend your effort making

71
00:03:30.319 --> 00:03:34.120
<v Speaker 1>the workflow intuitive correctly handled. Those validation steps stop being

72
00:03:34.199 --> 00:03:36.520
<v Speaker 1>roadblocks and start being part of a smooth narrative for

73
00:03:36.560 --> 00:03:38.639
<v Speaker 1>whoever's using the form. It might not feel like a

74
00:03:38.639 --> 00:03:41.840
<v Speaker 1>flashy win, but stopping the basic failures is what saves

75
00:03:41.879 --> 00:03:44.319
<v Speaker 1>you from a flood of low level tickets down the line.

76
00:03:44.439 --> 00:03:48.319
<v Speaker 1>Once Copilot shoulders the grunt work of generating accurate validation code,

77
00:03:48.360 --> 00:03:50.960
<v Speaker 1>your time shifts from survival mode to actually sharpening. How

78
00:03:50.960 --> 00:03:53.879
<v Speaker 1>the app behaves. That difference matters because when you see

79
00:03:53.879 --> 00:03:56.680
<v Speaker 1>how well targeted commands change the flow of code generation,

80
00:03:56.800 --> 00:03:59.439
<v Speaker 1>you start wondering what else those commands can unlock. And

81
00:03:59.479 --> 00:04:01.919
<v Speaker 1>that's when the real advantage of using Copilot with power

82
00:04:01.960 --> 00:04:06.319
<v Speaker 1>Pages becomes clear. Rolling advantage with Copilot commands. Rolling advantage

83
00:04:06.319 --> 00:04:08.960
<v Speaker 1>here means knowing the right commands to throw into Copilot

84
00:04:08.960 --> 00:04:11.800
<v Speaker 1>instead of hoping the dice land your way. That's the

85
00:04:11.840 --> 00:04:14.639
<v Speaker 1>real strength of using the AD power Pages participant. It

86
00:04:14.680 --> 00:04:18.000
<v Speaker 1>transforms Copilot Chat from a generic helper into a context

87
00:04:18.000 --> 00:04:21.199
<v Speaker 1>aware partner built for your power Pages environment. Here's how

88
00:04:21.199 --> 00:04:24.399
<v Speaker 1>you invoke it inside vs code, open the Copilot Chat

89
00:04:24.399 --> 00:04:27.040
<v Speaker 1>pain and then type your prompt with AD power Pages

90
00:04:27.040 --> 00:04:29.439
<v Speaker 1>at the front. That tag is what signals Copilot to

91
00:04:29.480 --> 00:04:32.120
<v Speaker 1>load the power Page's brain instead of the vanilla mode.

92
00:04:32.480 --> 00:04:36.360
<v Speaker 1>You can ask for validatas liquid snippets even data verse

93
00:04:36.399 --> 00:04:39.360
<v Speaker 1>bound calls, and Copilot will shape its answers to fit

94
00:04:39.439 --> 00:04:42.800
<v Speaker 1>the system you're actually coding against. Now, before that works,

95
00:04:42.920 --> 00:04:45.600
<v Speaker 1>you need the right load out visual Studio code installed,

96
00:04:45.680 --> 00:04:49.079
<v Speaker 1>the power Platform Tools extension, the GitHub Copilot Chat extension,

97
00:04:49.120 --> 00:04:52.720
<v Speaker 1>and the power Platform CLI authenticated against your data verse environment.

98
00:04:53.519 --> 00:04:56.839
<v Speaker 1>The authentication step matters the most because Copilot only understands

99
00:04:56.879 --> 00:04:59.519
<v Speaker 1>your environment once you've actually pulled the site content into

100
00:04:59.600 --> 00:05:02.279
<v Speaker 1>vs code while logged in. Without that, it's just guessing

101
00:05:02.600 --> 00:05:05.639
<v Speaker 1>and one governance caveat. Some Copilot features for power Pages

102
00:05:05.639 --> 00:05:08.360
<v Speaker 1>are still in preview and tenant admin's control whether they're

103
00:05:08.480 --> 00:05:11.800
<v Speaker 1>enabled through the Copilot hub and governance settings. Don't be

104
00:05:11.800 --> 00:05:14.079
<v Speaker 1>surprised if features demoed here are switched off in your ORC.

105
00:05:14.160 --> 00:05:16.480
<v Speaker 1>That's an admin toggle, not a bug. Here's the difference.

106
00:05:16.519 --> 00:05:19.240
<v Speaker 1>Once you're set up regular copilot is like asking a

107
00:05:19.240 --> 00:05:22.439
<v Speaker 1>bard for battlefield advice. You'll get a pleasant tune, maybe

108
00:05:22.439 --> 00:05:24.720
<v Speaker 1>some broad commentary, but none of the detail you need

109
00:05:24.720 --> 00:05:27.759
<v Speaker 1>when you're dealing with liquid templates or dataverse entity fields.

110
00:05:28.279 --> 00:05:30.680
<v Speaker 1>The ad power Pages participant is closer to a ranger

111
00:05:30.680 --> 00:05:33.680
<v Speaker 1>who's already mapped the terrain. It's not just code that compiles.

112
00:05:33.680 --> 00:05:37.319
<v Speaker 1>Its code that references the correct bindings, fits into form validators,

113
00:05:37.319 --> 00:05:40.920
<v Speaker 1>and aligns with how power Pages actually runs. One matterph

114
00:05:41.040 --> 00:05:44.839
<v Speaker 1>one contrast, one payoff usable context aware output instead of

115
00:05:44.839 --> 00:05:48.120
<v Speaker 1>fragile generic snippets. Let's talk results. If you ask Plain

116
00:05:48.199 --> 00:05:51.040
<v Speaker 1>Copilot for a validation routine, you'll probably get a script

117
00:05:51.040 --> 00:05:53.199
<v Speaker 1>that works in a bare bones HTMIL form. Drop it

118
00:05:53.199 --> 00:05:55.720
<v Speaker 1>into power pages, though, and you'll hit blind spots, no

119
00:05:55.800 --> 00:05:58.839
<v Speaker 1>recognition of entity schema, no clue what liquid tags are doing,

120
00:05:59.000 --> 00:06:01.879
<v Speaker 1>and definitely no aware of data verse rules. It runs

121
00:06:01.920 --> 00:06:05.040
<v Speaker 1>like duct tape, sticky but unreliable. Throw the same request

122
00:06:05.079 --> 00:06:07.360
<v Speaker 1>with add power Pages in the lead, and suddenly you've

123
00:06:07.360 --> 00:06:09.519
<v Speaker 1>got validators that don't just run, they bind to the

124
00:06:09.600 --> 00:06:12.879
<v Speaker 1>right entity field references. You actually need same request contact,

125
00:06:12.920 --> 00:06:16.279
<v Speaker 1>adjusted output, no midnight patch session required. And this isn't

126
00:06:16.319 --> 00:06:19.839
<v Speaker 1>just about generating scripts. Commands like ad power pages explain

127
00:06:19.879 --> 00:06:22.959
<v Speaker 1>the following code. Percent include a page copy. Percent give

128
00:06:23.000 --> 00:06:26.560
<v Speaker 1>you plain English walkthroughs of liquid or power pages specific constructs.

129
00:06:26.680 --> 00:06:30.000
<v Speaker 1>You're not copy pasting blind. You're actually building understanding. That's

130
00:06:30.000 --> 00:06:32.199
<v Speaker 1>a different kind of power because you're learning the ruins

131
00:06:32.240 --> 00:06:35.519
<v Speaker 1>while also casting them. The longer you work with these commands,

132
00:06:35.680 --> 00:06:38.800
<v Speaker 1>the more your workflow shifts. Instead of patching errors alone

133
00:06:38.920 --> 00:06:41.879
<v Speaker 1>at two am, you're treating copilot like a second set

134
00:06:41.920 --> 00:06:44.639
<v Speaker 1>of eyes that already knows what broke inside ninety percent

135
00:06:44.639 --> 00:06:47.560
<v Speaker 1>of similar bills. The commands don't give you cheat codes.

136
00:06:47.639 --> 00:06:50.279
<v Speaker 1>They give you inside and working samples that respect the

137
00:06:50.360 --> 00:06:53.519
<v Speaker 1>environment's quirks. They save you from endless rework cycles. On

138
00:06:53.560 --> 00:06:56.240
<v Speaker 1>a regular Copilot roll, you'll land somewhere in the middle.

139
00:06:56.720 --> 00:06:59.800
<v Speaker 1>Decent script extra rework some trial and error before it fits.

140
00:07:00.240 --> 00:07:02.600
<v Speaker 1>On an AD Power Pages roll, it feels like a

141
00:07:02.680 --> 00:07:07.160
<v Speaker 1>natural twenty validation scripts slot neatly into your power page's form.

142
00:07:07.199 --> 00:07:10.519
<v Speaker 1>Liquid includes actually past data. Verse bindings don't throw errors.

143
00:07:10.639 --> 00:07:13.519
<v Speaker 1>It's not luck, it's what happens when Copilot knows the

144
00:07:13.600 --> 00:07:16.680
<v Speaker 1>terrain your coding against. That advantage only gets you the

145
00:07:16.680 --> 00:07:20.279
<v Speaker 1>first draft. Though a working snippet doesn't mean a finished experience.

146
00:07:20.759 --> 00:07:23.639
<v Speaker 1>Users type weird inputs, error messages need detail, and scripts

147
00:07:23.639 --> 00:07:26.279
<v Speaker 1>have to evolve past the skeleton draft that Copilot hands you,

148
00:07:26.639 --> 00:07:29.759
<v Speaker 1>and that's where the next challenge begins. From script skeletons

149
00:07:29.759 --> 00:07:32.519
<v Speaker 1>to fully armored code, from script skeletons to fully armored

150
00:07:32.519 --> 00:07:35.560
<v Speaker 1>code starts where most validation does. In bare bones, you

151
00:07:35.639 --> 00:07:38.399
<v Speaker 1>get a first draft, a plan script that technically runs,

152
00:07:38.399 --> 00:07:41.199
<v Speaker 1>but blocks only the most obvious nonsense. Think of it

153
00:07:41.240 --> 00:07:44.000
<v Speaker 1>as a level one fighter holding a cardboard shield. It

154
00:07:44.079 --> 00:07:45.959
<v Speaker 1>works for one or two week hits, but the moment

155
00:07:46.079 --> 00:07:48.839
<v Speaker 1>real users starts swinging, the thing splinters. Anyone who has

156
00:07:48.879 --> 00:07:51.120
<v Speaker 1>shipped a form knows the script never lasts long. In

157
00:07:51.160 --> 00:07:54.319
<v Speaker 1>its starter state. You guard against easy mistakes. But then

158
00:07:54.360 --> 00:07:57.040
<v Speaker 1>a user pasts an emoji into a phone field or

159
00:07:57.120 --> 00:08:00.519
<v Speaker 1>types tomorrow for their birth date. Suddenly your defense collapses,

160
00:08:00.560 --> 00:08:03.000
<v Speaker 1>Tickets hit your inbox, and you're left with brittle validation

161
00:08:03.079 --> 00:08:05.639
<v Speaker 1>doing little more than shaking its arms. The root issue

162
00:08:05.680 --> 00:08:08.879
<v Speaker 1>isn't just validation coverage. It's the feedback. A message like

163
00:08:09.040 --> 00:08:12.120
<v Speaker 1>invalid input is the software equivalent of a locked door

164
00:08:12.120 --> 00:08:14.839
<v Speaker 1>with no sign. It tells users nothing, so they guess,

165
00:08:14.879 --> 00:08:17.480
<v Speaker 1>fail again, and eventually throw the problem at you. That's

166
00:08:17.480 --> 00:08:20.759
<v Speaker 1>when your help desk tickets multiply for the same predictable reasons.

167
00:08:21.079 --> 00:08:24.040
<v Speaker 1>Here's the shift. Those cardboard scripts don't need to stay fragile.

168
00:08:24.480 --> 00:08:27.199
<v Speaker 1>With Copilot. You don't just accept the skeleton. You iterate

169
00:08:27.240 --> 00:08:30.120
<v Speaker 1>it into armor, and the workflow is simple enough to remember,

170
00:08:30.160 --> 00:08:33.519
<v Speaker 1>like a four step loop. Generate the skeleton, ask Copilot

171
00:08:33.559 --> 00:08:36.279
<v Speaker 1>to improve error messages, then add edge case handling, and

172
00:08:36.320 --> 00:08:39.679
<v Speaker 1>finally deploy. Every step upgrades the thin hilt into an

173
00:08:39.679 --> 00:08:42.600
<v Speaker 1>actual weapon you'd trust in the field. Copilot works in session,

174
00:08:42.879 --> 00:08:45.879
<v Speaker 1>which makes this fast because you're inside the same chat

175
00:08:45.960 --> 00:08:48.720
<v Speaker 1>where the skeleton came from you just type update code

176
00:08:48.720 --> 00:08:52.120
<v Speaker 1>and write detailed error messages. Copilot doesn't start from zero.

177
00:08:52.200 --> 00:08:55.039
<v Speaker 1>It literally updates the code you had right in your editor.

178
00:08:55.519 --> 00:08:58.840
<v Speaker 1>No spinning between browser tabs or rebuilding prompts from scratch.

179
00:08:59.120 --> 00:09:01.320
<v Speaker 1>It's iterative, not guess and paste, and you can see

180
00:09:01.320 --> 00:09:04.360
<v Speaker 1>the impact immediately. Imagine the before and after your first

181
00:09:04.440 --> 00:09:09.000
<v Speaker 1>draft throws invalid input. After one refinement, it reads phone

182
00:09:09.039 --> 00:09:11.879
<v Speaker 1>number must be digits only and at least ten characters.

183
00:09:12.240 --> 00:09:15.399
<v Speaker 1>That clarity transforms user experience. Instead of a wall, you

184
00:09:15.440 --> 00:09:17.960
<v Speaker 1>build a rope guide. They know what went wrong and

185
00:09:17.960 --> 00:09:21.039
<v Speaker 1>how to fix it themselves. No ticket, no grumbling, less

186
00:09:21.039 --> 00:09:23.799
<v Speaker 1>wasted time on your side. Push again for edge cases,

187
00:09:23.799 --> 00:09:26.679
<v Speaker 1>and Copilot expands the armor. Need to check for special

188
00:09:26.759 --> 00:09:30.559
<v Speaker 1>characters sneaking into numeric fields prompt Copilot in the same thread,

189
00:09:30.919 --> 00:09:34.519
<v Speaker 1>want more layered responses for different failure types, same workflow.

190
00:09:34.720 --> 00:09:37.039
<v Speaker 1>Each time the script hardens a little more, and it

191
00:09:37.080 --> 00:09:39.720
<v Speaker 1>does so with context tied to your power pages environment,

192
00:09:39.799 --> 00:09:42.559
<v Speaker 1>not just generic web code. What's really happening is a

193
00:09:42.639 --> 00:09:45.399
<v Speaker 1>change in how you debug. You stop firefighting single lines

194
00:09:45.399 --> 00:09:49.000
<v Speaker 1>of broken syntax and start sculpting working drafts. Copilot already

195
00:09:49.039 --> 00:09:51.440
<v Speaker 1>hands you a functioning baseline, so your energy goes into

196
00:09:51.440 --> 00:09:54.960
<v Speaker 1>polishing instead of trial and error over syntax quirks. You're

197
00:09:54.960 --> 00:09:57.600
<v Speaker 1>deliberately shaping how the code speaks back to the user.

198
00:09:57.720 --> 00:10:00.960
<v Speaker 1>That cuts rework hours and trims down. So when you

199
00:10:01.000 --> 00:10:04.399
<v Speaker 1>look at it through that loop skeleton, refine messages, harden

200
00:10:04.440 --> 00:10:07.519
<v Speaker 1>against edge cases, deploy, you realize you're not only preventing

201
00:10:07.600 --> 00:10:11.559
<v Speaker 1>data chaos, but actively reducing future support load. Every crafted

202
00:10:11.639 --> 00:10:14.399
<v Speaker 1>error message is one less why doesn't this work ticket

203
00:10:14.399 --> 00:10:17.440
<v Speaker 1>in your queue. Every edge case handled is one less

204
00:10:17.480 --> 00:10:20.120
<v Speaker 1>fragile field waiting to blow up in production. By the

205
00:10:20.120 --> 00:10:23.360
<v Speaker 1>time Copalot's refinements are layered in, the skeleton still exists

206
00:10:23.440 --> 00:10:26.399
<v Speaker 1>under the armor, but it's completely transformed. What began as

207
00:10:26.440 --> 00:10:30.080
<v Speaker 1>a stop gap becomes something resilient enough for production data

208
00:10:30.120 --> 00:10:33.000
<v Speaker 1>with feedback that educates the user instead of blocking them.

209
00:10:33.200 --> 00:10:35.720
<v Speaker 1>Like a paper shield reforged into plate. It changes how

210
00:10:35.799 --> 00:10:38.000
<v Speaker 1>the fight feels on both sides of the screen, and

211
00:10:38.039 --> 00:10:41.039
<v Speaker 1>while scripted validation is one piece of the puzzle, there's

212
00:10:41.080 --> 00:10:43.720
<v Speaker 1>a bigger battlefield around it. The code can be armored,

213
00:10:43.879 --> 00:10:46.039
<v Speaker 1>but the question becomes how do you manage the entire

214
00:10:46.080 --> 00:10:48.840
<v Speaker 1>structure It lives inside without slowing down. That's where the

215
00:10:48.879 --> 00:10:51.279
<v Speaker 1>next challenge shows up, not in the script itself, but

216
00:10:51.360 --> 00:10:53.360
<v Speaker 1>in the way you handle the map of your site.

217
00:10:54.440 --> 00:10:57.320
<v Speaker 1>Editing the dungeon map with CLI and vs code. When

218
00:10:57.320 --> 00:10:59.720
<v Speaker 1>you want to move beyond single scripts and start managing

219
00:10:59.720 --> 00:11:02.600
<v Speaker 1>your hole old side, you need more than brute force edits.

220
00:11:02.639 --> 00:11:05.399
<v Speaker 1>You need a proper map. Editing the dungeon map with

221
00:11:05.480 --> 00:11:08.080
<v Speaker 1>CLI and VS code is how you stop wandering blind

222
00:11:08.120 --> 00:11:10.799
<v Speaker 1>hallways and instead keep every corridor in plain sight. The

223
00:11:10.799 --> 00:11:13.440
<v Speaker 1>messy way is juggling tabs in the browser design studio,

224
00:11:13.799 --> 00:11:16.159
<v Speaker 1>bouncing over to a terminal, then shuffling files back and

225
00:11:16.200 --> 00:11:18.279
<v Speaker 1>forth just to make a minor change. It works, but

226
00:11:18.360 --> 00:11:21.159
<v Speaker 1>it feels clunky. The integrated way is downloading all your

227
00:11:21.200 --> 00:11:24.120
<v Speaker 1>side content locally with the power Platform CLI, then editing

228
00:11:24.120 --> 00:11:27.320
<v Speaker 1>and deploying through the power Platform Tools extension in vs code.

229
00:11:27.399 --> 00:11:30.240
<v Speaker 1>One workflow, no half step dance. Here's how it plays.

230
00:11:30.519 --> 00:11:34.399
<v Speaker 1>Before you do anything, you authenticate against your data verse environment.

231
00:11:34.879 --> 00:11:37.039
<v Speaker 1>Think of it as unlocking the front door so the

232
00:11:37.039 --> 00:11:40.679
<v Speaker 1>CLI can actually reach your site. Once authenticated, you run

233
00:11:40.720 --> 00:11:44.399
<v Speaker 1>a single command to download website content into your local workspace.

234
00:11:44.960 --> 00:11:48.960
<v Speaker 1>That pull brings down the templates, scripts, CSS, and assets,

235
00:11:49.159 --> 00:11:52.559
<v Speaker 1>an entire copy of your site's insights onto your machine.

236
00:11:52.799 --> 00:11:55.960
<v Speaker 1>Copilot also benefits because with local files in place, it

237
00:11:55.960 --> 00:11:59.799
<v Speaker 1>can reference environments specific entities instead of lobbing generic gases

238
00:12:00.279 --> 00:12:02.879
<v Speaker 1>from there. You're always in VS code. Want to adjust

239
00:12:02.879 --> 00:12:05.919
<v Speaker 1>a liquid template, the file is right there, fixed validation logic,

240
00:12:06.080 --> 00:12:08.600
<v Speaker 1>open the JavaScript file sitting beside it. And because it's

241
00:12:08.639 --> 00:12:11.240
<v Speaker 1>all centralized, you see in real time how pieces connect,

242
00:12:11.360 --> 00:12:14.000
<v Speaker 1>rather than toggling between tools with no context of the

243
00:12:14.000 --> 00:12:17.440
<v Speaker 1>bigger picture. The power Platform Tools extension makes the CLI

244
00:12:17.480 --> 00:12:20.240
<v Speaker 1>commands digestible. You still have the raw command line at

245
00:12:20.279 --> 00:12:23.279
<v Speaker 1>your disposal, but they live in vs codes integrated terminal,

246
00:12:23.320 --> 00:12:26.519
<v Speaker 1>now tied to the workspace you're already coding in. That

247
00:12:26.639 --> 00:12:29.399
<v Speaker 1>means no memorizing long strings every time you run the

248
00:12:29.440 --> 00:12:33.960
<v Speaker 1>same short commands consistently download, edit, deploy, smooth cycle, no

249
00:12:34.120 --> 00:12:37.519
<v Speaker 1>left over fragments, sneaking out of sync. Deployment itself simplifies

250
00:12:37.559 --> 00:12:40.799
<v Speaker 1>to after making edits, you use the same CLI powered

251
00:12:40.799 --> 00:12:44.159
<v Speaker 1>workflow to push changes back into your power Pages environment.

252
00:12:44.519 --> 00:12:47.080
<v Speaker 1>That closes the loop without the usual double handling or

253
00:12:47.200 --> 00:12:51.360
<v Speaker 1>version mishaps. You aren't copying folders manually or hoping your

254
00:12:51.360 --> 00:12:54.360
<v Speaker 1>browser session hasn't timed out. You're keeping everything in one

255
00:12:54.440 --> 00:12:58.519
<v Speaker 1>environment you actually control, and the productivity gain really shows

256
00:12:58.559 --> 00:13:00.919
<v Speaker 1>once you add copilot into that lie. Instead of juggling

257
00:13:00.960 --> 00:13:04.480
<v Speaker 1>disconnected snippets, now your AT power Pages prompts happen in

258
00:13:04.519 --> 00:13:06.840
<v Speaker 1>the same workspace as your side content. You can tweak

259
00:13:06.879 --> 00:13:09.679
<v Speaker 1>a validation script and immediately test how it interacts with

260
00:13:09.679 --> 00:13:12.919
<v Speaker 1>liquid templates two taps away. It's one environment, one context,

261
00:13:12.919 --> 00:13:15.799
<v Speaker 1>one step from question to answer. To make it concrete,

262
00:13:15.960 --> 00:13:18.080
<v Speaker 1>I'll show you in a short demo. Run one CLI

263
00:13:18.080 --> 00:13:20.679
<v Speaker 1>command to pull your side down. Open both a page's

264
00:13:20.720 --> 00:13:23.799
<v Speaker 1>liquid file and its validation script in VS code, then

265
00:13:23.840 --> 00:13:26.720
<v Speaker 1>ask AD power pages to upgrade the error messages. That's

266
00:13:26.759 --> 00:13:29.279
<v Speaker 1>the whole cycle map in front of you, files in

267
00:13:29.320 --> 00:13:33.720
<v Speaker 1>reach AI assistant on standby. The real win isn't that

268
00:13:33.759 --> 00:13:36.879
<v Speaker 1>you add more tools, it's that you consolidate them. You

269
00:13:36.919 --> 00:13:40.559
<v Speaker 1>eliminate context switches, stay focused, and work inside one stable

270
00:13:40.600 --> 00:13:43.639
<v Speaker 1>frame where the coding, content and assistance line up together.

271
00:13:43.919 --> 00:13:46.519
<v Speaker 1>It saves time, but more importantly, it keeps you from

272
00:13:46.559 --> 00:13:49.200
<v Speaker 1>burning energy on distractions instead of on the actual build.

273
00:13:49.559 --> 00:13:51.519
<v Speaker 1>With the map finally in your hands, you're no longer

274
00:13:51.559 --> 00:13:54.440
<v Speaker 1>stumbling around wondering where the next choke point is. But

275
00:13:54.559 --> 00:13:57.360
<v Speaker 1>even with the dungeon layout clear, some fights remain because

276
00:13:57.879 --> 00:13:59.840
<v Speaker 1>when the boss shows up masked as a heap of

277
00:13:59.840 --> 00:14:02.279
<v Speaker 1>debug errors, the real test is whether you can read

278
00:14:02.320 --> 00:14:05.559
<v Speaker 1>its attack pattern, and that's a battle. Many developers still

279
00:14:05.600 --> 00:14:09.720
<v Speaker 1>go into blind debugging boss battles with Copilot inside. Sometimes

280
00:14:09.759 --> 00:14:11.720
<v Speaker 1>the real test isn't writing new code at all, it's

281
00:14:11.720 --> 00:14:15.320
<v Speaker 1>figuring out why something you thought was fine suddenly turns hostile.

282
00:14:16.000 --> 00:14:20.120
<v Speaker 1>That's where debugging boss battles with copilot insight comes into play.

283
00:14:20.279 --> 00:14:22.879
<v Speaker 1>Power pages debugging can feel like trading blows with a

284
00:14:22.919 --> 00:14:26.639
<v Speaker 1>boss monster hiding its attack pattern. Errors look random, the

285
00:14:26.720 --> 00:14:30.320
<v Speaker 1>logs scream without context. You dig through long scripts, unsure

286
00:14:30.320 --> 00:14:33.120
<v Speaker 1>if the problem is syntax, a liquid tag, misfire, or

287
00:14:33.200 --> 00:14:35.840
<v Speaker 1>data verse bindings. Refusing to cooperate what should have been

288
00:14:35.840 --> 00:14:38.360
<v Speaker 1>a quick fix eats an entire session because you're translating

289
00:14:38.399 --> 00:14:41.919
<v Speaker 1>gibberish line by line. Liquid makes this harder. A tiny

290
00:14:41.919 --> 00:14:45.879
<v Speaker 1>tag can change the page, sometimes neatly, sometimes spectacularly wrong.

291
00:14:46.720 --> 00:14:50.720
<v Speaker 1>One pen include percent drops in content without fuss, another,

292
00:14:50.799 --> 00:14:54.080
<v Speaker 1>in a slightly different context, tanks your whole layout. Data

293
00:14:54.159 --> 00:14:57.080
<v Speaker 1>verse bindings add more friction. They may resolve correctly on

294
00:14:57.080 --> 00:15:00.559
<v Speaker 1>one form and fail silently on another. Microsoft's own guidance

295
00:15:00.559 --> 00:15:04.200
<v Speaker 1>acknowledges the quirk liquid and data verse behave differently depending

296
00:15:04.200 --> 00:15:07.159
<v Speaker 1>on placement, which means just move it around until it works.

297
00:15:07.399 --> 00:15:11.399
<v Speaker 1>Becomes your unofficial workflow. That's precisely where copilots at power

298
00:15:11.399 --> 00:15:14.440
<v Speaker 1>pages participants shifts your odds. Instead of burning an afternoon

299
00:15:14.519 --> 00:15:17.639
<v Speaker 1>running blind experiments, you can put the code under a spotlight.

300
00:15:17.799 --> 00:15:20.879
<v Speaker 1>You literally type at power pages, explain the following code

301
00:15:21.240 --> 00:15:26.360
<v Speaker 1>percent include page copy percent into copilot chat, no hand waving,

302
00:15:26.559 --> 00:15:30.080
<v Speaker 1>no generic advice. The output is a plane language walk through,

303
00:15:30.159 --> 00:15:32.559
<v Speaker 1>explaining what that tag does, what it pulls in, and

304
00:15:32.639 --> 00:15:35.679
<v Speaker 1>why its position on the page affects behavior. In effect,

305
00:15:35.720 --> 00:15:38.440
<v Speaker 1>you stop guessing and finally have a readable script of

306
00:15:38.440 --> 00:15:41.440
<v Speaker 1>the boss's Moveset. To make the most of it, structure

307
00:15:41.440 --> 00:15:44.679
<v Speaker 1>your debugging like a quick demo. First, identify the buggy

308
00:15:44.679 --> 00:15:47.960
<v Speaker 1>snippet a form implodes after an include tag. Second, drop

309
00:15:48.000 --> 00:15:51.080
<v Speaker 1>the exact code into Copilot with the explain command. Third,

310
00:15:51.120 --> 00:15:54.840
<v Speaker 1>apply Copilot's explanation to a small rewrite or layout adjustment.

311
00:15:55.200 --> 00:15:58.279
<v Speaker 1>Then test the steps are compact, explain, apply, test you

312
00:15:58.320 --> 00:16:00.960
<v Speaker 1>see results without getting trapped in anless trial and error,

313
00:16:01.279 --> 00:16:03.879
<v Speaker 1>and Copilot goes further than translation. In the same chat,

314
00:16:03.919 --> 00:16:06.279
<v Speaker 1>you can ask for a fix. For example, Copilot can

315
00:16:06.320 --> 00:16:08.840
<v Speaker 1>suggest adjusting how the include is nested so it plays

316
00:16:08.840 --> 00:16:11.879
<v Speaker 1>well with your layout, or it might tweak javascriptso and

317
00:16:12.000 --> 00:16:15.679
<v Speaker 1>event handler fires without collapsing the console. Because it's running

318
00:16:15.679 --> 00:16:19.039
<v Speaker 1>context aware in your power page's workspace. The advice connects

319
00:16:19.039 --> 00:16:22.039
<v Speaker 1>directly to your environment, rather than floating in generic webspace.

320
00:16:22.120 --> 00:16:24.960
<v Speaker 1>That's the difference between a random potion vendor and someone

321
00:16:24.960 --> 00:16:27.919
<v Speaker 1>who actually knows the boss you're fighting. The benefit is immediate.

322
00:16:27.960 --> 00:16:30.440
<v Speaker 1>Instead of spending half a day isolating one broken binding,

323
00:16:30.600 --> 00:16:33.159
<v Speaker 1>you cut straight to understanding why it fails. That turns

324
00:16:33.159 --> 00:16:36.279
<v Speaker 1>debugging from a grindy randomness into something tactical. You see

325
00:16:36.320 --> 00:16:38.519
<v Speaker 1>what broke, apply a focused patch, and confirm if the

326
00:16:38.519 --> 00:16:41.159
<v Speaker 1>behavior stabilizes. It feels less like pulling dice from a

327
00:16:41.159 --> 00:16:44.279
<v Speaker 1>cursed bag and more like reacting to visible patterns. Here's

328
00:16:44.279 --> 00:16:48.000
<v Speaker 1>the contrast. In practice, before an error message like something

329
00:16:48.039 --> 00:16:52.200
<v Speaker 1>went wrong left you circling the problem endlessly. With Copilot's explanation,

330
00:16:52.240 --> 00:16:55.519
<v Speaker 1>you learn that the include tag loads a specific page fragment,

331
00:16:55.799 --> 00:16:58.960
<v Speaker 1>and in your placement. It overwrote a required container. You

332
00:16:59.039 --> 00:17:02.200
<v Speaker 1>rewrite the placement as Copilot suggests, retest, and the form holds.

333
00:17:02.559 --> 00:17:06.279
<v Speaker 1>In three steps, you move from confusion to resolution. Of course,

334
00:17:06.279 --> 00:17:09.599
<v Speaker 1>there's a rule worth repeating. Copilot makes strong suggestions, but

335
00:17:09.640 --> 00:17:12.799
<v Speaker 1>it's not a guarantee. Always review and test before deploying

336
00:17:12.839 --> 00:17:15.680
<v Speaker 1>to production. Treat their outputs as a strategy guide, not

337
00:17:15.720 --> 00:17:18.519
<v Speaker 1>as instant loot. You can equip blind. They save time,

338
00:17:18.519 --> 00:17:21.160
<v Speaker 1>but your judgment keeps the system stable. Once you build

339
00:17:21.160 --> 00:17:23.920
<v Speaker 1>that feedback loop, explain a just confirm, you chip away

340
00:17:23.960 --> 00:17:26.839
<v Speaker 1>at the intimidation factor of debugging. Liquid no longer feels

341
00:17:26.920 --> 00:17:30.519
<v Speaker 1>like a chaotic trickster. Data verse quirks stop being total mysteries,

342
00:17:30.880 --> 00:17:34.319
<v Speaker 1>and even JavaScript surprises turn into manageable counter attacks. A

343
00:17:34.319 --> 00:17:36.519
<v Speaker 1>boss battle is still a challenge, but you're fighting with

344
00:17:36.640 --> 00:17:39.480
<v Speaker 1>vision instead of taking hits at random angles, and that

345
00:17:39.559 --> 00:17:42.519
<v Speaker 1>change in perspective is the real win. Debugging with copilot

346
00:17:42.559 --> 00:17:45.759
<v Speaker 1>insight doesn't erase the encounter. You still code, you still test,

347
00:17:45.799 --> 00:17:49.160
<v Speaker 1>You still troubleshoot, but you stop wasting energy squinting at

348
00:17:49.200 --> 00:17:52.640
<v Speaker 1>mysterious outputs and start rolling with reliable advantage, which sets

349
00:17:52.640 --> 00:17:55.279
<v Speaker 1>the stage for the final piece. What all these changes

350
00:17:55.319 --> 00:17:57.279
<v Speaker 1>add up to Once you step back and look at

351
00:17:57.319 --> 00:18:01.160
<v Speaker 1>the bigger quest, conclusion comes down to this, Copilot isn't

352
00:18:01.160 --> 00:18:03.759
<v Speaker 1>skipping fights, it's changing how you take them. You move

353
00:18:03.799 --> 00:18:06.680
<v Speaker 1>from fragile trial and error into AI assisted code that

354
00:18:06.720 --> 00:18:10.680
<v Speaker 1>explains itself, refines on command, and builds flows. Users can

355
00:18:10.720 --> 00:18:13.839
<v Speaker 1>actually navigate without rage quitting. Here are your five wins.

356
00:18:13.920 --> 00:18:17.400
<v Speaker 1>Streamline liquid templates, speed up JavaScript and form validation, get

357
00:18:17.400 --> 00:18:20.640
<v Speaker 1>plain English explanations for tricky snippets, slot in HTML and

358
00:18:20.640 --> 00:18:25.559
<v Speaker 1>bootstrap for responsive layouts, and simplify web API calls without guesswork.

359
00:18:25.920 --> 00:18:29.039
<v Speaker 1>Some features are still in preview. Tenant admins toggle them

360
00:18:29.039 --> 00:18:31.599
<v Speaker 1>through the Copilot hub in the power Platform admin center,

361
00:18:31.720 --> 00:18:34.680
<v Speaker 1>so check with yours if pieces seem missing, boss down,

362
00:18:34.920 --> 00:18:37.640
<v Speaker 1>loot secured, equip the subscribe, buff ring the bell for

363
00:18:37.759 --> 00:18:40.039
<v Speaker 1>future demos, and drop a comment with the one validation

364
00:18:40.200 --> 00:18:43.039
<v Speaker 1>or liquid problem you'd like Copilot to tackle. Next. Will

365
00:18:43.079 --> 00:18:45.400
<v Speaker 1>sharpen future walkthroughs on your toughest tickets