WEBVTT

1
00:00:00.080 --> 00:00:02.640
<v Speaker 1>Most people think power apps is about dragging buttons onto

2
00:00:02.720 --> 00:00:07.240
<v Speaker 1>screens until something vaguely resembling an app appears. Click, drag, published,

3
00:00:07.320 --> 00:00:10.640
<v Speaker 1>done wrong. That's the fairy tale version Microsoft marketed to

4
00:00:10.720 --> 00:00:14.199
<v Speaker 1>empower everyone, and it worked too well, because now there's

5
00:00:14.199 --> 00:00:17.440
<v Speaker 1>a new species loose in the ecosystem, vibe code. That's

6
00:00:17.480 --> 00:00:21.359
<v Speaker 1>the evolution where power apps meet serious development equal parts JavaScript,

7
00:00:21.399 --> 00:00:24.960
<v Speaker 1>get discipline and AI assisted chaos. See. Power apps started

8
00:00:25.000 --> 00:00:28.519
<v Speaker 1>as a playground for business users citizen developers, armed with

9
00:00:28.640 --> 00:00:33.000
<v Speaker 1>enthusiasm and questionable naming conventions. The dream was simple, build

10
00:00:33.039 --> 00:00:35.920
<v Speaker 1>your own app without writing code, and yes, you could

11
00:00:35.920 --> 00:00:38.079
<v Speaker 1>whip up a form faster than it takes itty to

12
00:00:38.079 --> 00:00:42.000
<v Speaker 1>say governance policy. But somewhere between the fifth nested formula

13
00:00:42.039 --> 00:00:44.840
<v Speaker 1>in power effects and the third unexplained delegation warning, the

14
00:00:44.920 --> 00:00:49.159
<v Speaker 1>dream cracked. Enter the schism citizen devs versus professional depths

15
00:00:49.159 --> 00:00:51.560
<v Speaker 1>on one side, the drag and drop romantics who swear

16
00:00:51.600 --> 00:00:54.399
<v Speaker 1>by speed and flexibility. On the other, the pro coders

17
00:00:54.399 --> 00:00:56.640
<v Speaker 1>who look at canvas app formulas and feel a deep

18
00:00:56.679 --> 00:00:59.920
<v Speaker 1>existential dread. One group lives for instant results, the other

19
00:01:00.000 --> 00:01:03.560
<v Speaker 1>demands reusable components, source control, and environments that don't break

20
00:01:03.560 --> 00:01:06.400
<v Speaker 1>when someone renames the field now code apps, or as

21
00:01:06.400 --> 00:01:09.760
<v Speaker 1>I prefer, vibe code, bring that missing discipline back. They

22
00:01:09.799 --> 00:01:12.840
<v Speaker 1>let you use visual studio code, proper frameworks like React,

23
00:01:13.159 --> 00:01:16.560
<v Speaker 1>and still live inside the power platform's luxurious, compliance approved

24
00:01:16.560 --> 00:01:20.239
<v Speaker 1>walled garden. It's not rebellion. It's a truce between creativity

25
00:01:20.280 --> 00:01:22.879
<v Speaker 1>and control. By the end of this you'll know exactly

26
00:01:22.920 --> 00:01:25.319
<v Speaker 1>when vibe code wins, when low code saves the day,

27
00:01:25.359 --> 00:01:28.239
<v Speaker 1>and how GitHub Copilot glues the two worlds together faster

28
00:01:28.319 --> 00:01:31.079
<v Speaker 1>than any junior dev could. We're about to unpack the

29
00:01:31.120 --> 00:01:34.760
<v Speaker 1>illusion of simplicity, the metrics of scale, and the AI

30
00:01:34.840 --> 00:01:37.920
<v Speaker 1>that's pulling the strings between both worlds. So forget everything

31
00:01:37.959 --> 00:01:40.599
<v Speaker 1>you think you know about power apps, because low code

32
00:01:40.599 --> 00:01:43.200
<v Speaker 1>for everyone was never the real story. It was just

33
00:01:43.239 --> 00:01:46.400
<v Speaker 1>the prolog, the low code illusion. Low code sold a

34
00:01:46.439 --> 00:01:49.560
<v Speaker 1>convenient fantasy. Anyone could be a developer. That sounds noble

35
00:01:49.599 --> 00:01:52.879
<v Speaker 1>until you realize anyone includes Gary from Accounting, who just

36
00:01:52.920 --> 00:01:56.040
<v Speaker 1>built an app that performs twenty SQL queries every five seconds.

37
00:01:56.280 --> 00:01:59.719
<v Speaker 1>The promise was empowerment. The result syntax chaos disguised behind

38
00:01:59.760 --> 00:02:03.280
<v Speaker 1>power still colored buttons. Let's demystify it. Power apps comes

39
00:02:03.319 --> 00:02:06.040
<v Speaker 1>in two main flavors, canvas and model driven Canvas apps

40
00:02:06.079 --> 00:02:08.919
<v Speaker 1>are the design your own interface kind freedom incarnate. You

41
00:02:09.039 --> 00:02:11.719
<v Speaker 1>drag components onto a blank canvas, wire them up with

42
00:02:11.840 --> 00:02:15.840
<v Speaker 1>power effects, and feel like Picasso with an API. Model

43
00:02:15.919 --> 00:02:18.599
<v Speaker 1>driven apps, however, are the rule followers. They take your

44
00:02:18.680 --> 00:02:22.319
<v Speaker 1>data verse tables and automatically generate UI like a disciplined robot.

45
00:02:22.520 --> 00:02:25.639
<v Speaker 1>They're structured but rigid, perfect for data heavy use cases,

46
00:02:25.680 --> 00:02:28.520
<v Speaker 1>less so for anything that demands flare. Now, what both

47
00:02:28.560 --> 00:02:31.719
<v Speaker 1>share is speed. You can prototype in hours, sometimes minutes.

48
00:02:31.800 --> 00:02:34.840
<v Speaker 1>That's the dopamine hit. Microsoft built this empire on business

49
00:02:34.919 --> 00:02:38.319
<v Speaker 1>units didn't need it approval anymore. They could empower themselves.

50
00:02:38.840 --> 00:02:41.919
<v Speaker 1>But the hidden cost came later, maintenance nightmares that grew

51
00:02:42.000 --> 00:02:45.520
<v Speaker 1>like invasive plants across the enterprise. Because loco doesn't mean

52
00:02:45.560 --> 00:02:48.719
<v Speaker 1>low complexity, it just hides that complexity behind cheerful names

53
00:02:48.719 --> 00:02:51.439
<v Speaker 1>and mouse clicks. Take power effects, for example, it looks

54
00:02:51.479 --> 00:02:54.319
<v Speaker 1>harmless a little Excel inspired formula language for app logic,

55
00:02:54.680 --> 00:02:57.400
<v Speaker 1>but under the hood it creates sprawling dependency webs that

56
00:02:57.479 --> 00:03:00.479
<v Speaker 1>only the original creator can untangle. Loose their person and

57
00:03:00.520 --> 00:03:03.680
<v Speaker 1>you lose the logic. Governance tools can help sure but

58
00:03:03.759 --> 00:03:06.479
<v Speaker 1>most organizations end up with dozens of variations of the

59
00:03:06.520 --> 00:03:10.960
<v Speaker 1>same task tracker app, all slightly broken in unique fascinating ways.

60
00:03:11.159 --> 00:03:14.960
<v Speaker 1>The analogy is inevitable. Low code is ikea furniture. Assemble

61
00:03:14.960 --> 00:03:17.159
<v Speaker 1>it fast, feel competent, and then realize you don't know

62
00:03:17.199 --> 00:03:19.560
<v Speaker 1>where that extra bolt came from. Heaven help you if

63
00:03:19.560 --> 00:03:21.360
<v Speaker 1>you ever need to move it or upgrade it, because

64
00:03:21.360 --> 00:03:24.520
<v Speaker 1>there's always missing documentation and a mystery hex key. Involved

65
00:03:24.879 --> 00:03:28.120
<v Speaker 1>departments hit the tipping point, the moment they want serious integrations,

66
00:03:28.639 --> 00:03:32.840
<v Speaker 1>sequel back ends, GIT repositories, automated pipelines, canvas apps weren't

67
00:03:32.840 --> 00:03:35.479
<v Speaker 1>designed for that depth. They shine for quick process tools,

68
00:03:35.560 --> 00:03:39.280
<v Speaker 1>leave requests, status dashboards, but not full production grade systems

69
00:03:39.280 --> 00:03:43.000
<v Speaker 1>that must survive audits, scaling, and developer turnover. That's when

70
00:03:43.039 --> 00:03:45.919
<v Speaker 1>teams face the rewrite moment, where low codes convenience suddenly

71
00:03:45.960 --> 00:03:49.199
<v Speaker 1>becomes its cost. So Microsoft did something smart instead of

72
00:03:49.199 --> 00:03:52.319
<v Speaker 1>pretending the problem didn't exist, They equipped developers with a

73
00:03:52.319 --> 00:03:55.840
<v Speaker 1>new way to take back structure without abandoning the platform's benefits,

74
00:03:56.319 --> 00:03:58.719
<v Speaker 1>and thus Vibe Coode entered the chat, a form of

75
00:03:58.719 --> 00:04:00.919
<v Speaker 1>power apps that behaves like a modern web project but

76
00:04:00.960 --> 00:04:05.080
<v Speaker 1>still enjoys all the comforts of enterprise, governance, connectors, and authentication.

77
00:04:05.319 --> 00:04:08.520
<v Speaker 1>What's coming next flips the script entirely, because where low

78
00:04:08.520 --> 00:04:12.319
<v Speaker 1>code abstracted complexity away, code apps embrace it on your terms.

79
00:04:12.400 --> 00:04:15.520
<v Speaker 1>This isn't rebellion for its own sake. Its infrastructure therapy

80
00:04:15.680 --> 00:04:20.480
<v Speaker 1>delivered through syntax, enter vibecode, power apps, code apps. Now

81
00:04:20.480 --> 00:04:23.160
<v Speaker 1>we come to the grown up table. Vibcode or what

82
00:04:23.240 --> 00:04:26.600
<v Speaker 1>Microsoft humbly calls power apps. Code apps is what happens

83
00:04:26.600 --> 00:04:29.199
<v Speaker 1>when the power platform finally admits it's part of the

84
00:04:29.240 --> 00:04:32.959
<v Speaker 1>developer family. Again. Gone are the days of pastel interfaces

85
00:04:32.959 --> 00:04:35.639
<v Speaker 1>and formula boxes. This is React in a suit and tie,

86
00:04:35.759 --> 00:04:38.079
<v Speaker 1>hosted inside power apps. Think of it as a high

87
00:04:38.160 --> 00:04:41.519
<v Speaker 1>end condominium inside the same gated community, but this unit

88
00:04:41.519 --> 00:04:44.879
<v Speaker 1>has stainless steel, appliances and version control. Here's the simple version.

89
00:04:44.959 --> 00:04:48.040
<v Speaker 1>Code apps are full fledged React web applications that run

90
00:04:48.160 --> 00:04:51.240
<v Speaker 1>inside the power Platform. Yes, inside you write in your

91
00:04:51.279 --> 00:04:56.879
<v Speaker 1>favorite ID visual studio code using all the modern trimmings NODEJS, Typescript,

92
00:04:57.120 --> 00:05:00.000
<v Speaker 1>dot Net, and Git. The power platform gives you structure,

93
00:05:00.160 --> 00:05:04.079
<v Speaker 1>connectors and security. React gives you raw creative control. It's

94
00:05:04.120 --> 00:05:07.199
<v Speaker 1>the best of custom and controlled worlds the artistry of

95
00:05:07.279 --> 00:05:11.120
<v Speaker 1>a full stack dev inside Microsoft's carefully monitored walled garden.

96
00:05:11.439 --> 00:05:14.120
<v Speaker 1>Let's decode the workflow. It starts at the command line,

97
00:05:14.120 --> 00:05:17.399
<v Speaker 1>where developers feel most alive. You initialize a code app

98
00:05:17.639 --> 00:05:20.639
<v Speaker 1>using the power Platform Cli, a tool that connects your

99
00:05:20.639 --> 00:05:23.759
<v Speaker 1>local project directly to your power Platform environment. Then, with

100
00:05:23.839 --> 00:05:26.240
<v Speaker 1>a few commands like pack code in it, you bootstrap

101
00:05:26.240 --> 00:05:29.839
<v Speaker 1>a standard React project, configure your power config Jason, and

102
00:05:29.879 --> 00:05:32.480
<v Speaker 1>link it to your environment. This is the digital equivalent

103
00:05:32.519 --> 00:05:35.680
<v Speaker 1>of setting up residency. Your local machine meets the cloud

104
00:05:36.000 --> 00:05:39.399
<v Speaker 1>and shakes hands politely through authentication. From there, you bring

105
00:05:39.439 --> 00:05:42.600
<v Speaker 1>in connectors. Power app supports over one thousand, five hundred

106
00:05:42.639 --> 00:05:47.480
<v Speaker 1>of them, SharePoint, Esquill, Office three sixty five Service now, Azure,

107
00:05:47.560 --> 00:05:50.319
<v Speaker 1>and more. Add these directly into your app using the CLI,

108
00:05:50.360 --> 00:05:52.240
<v Speaker 1>and a new typescript service pops up like it was

109
00:05:52.279 --> 00:05:54.920
<v Speaker 1>always meant to be. There, no silly formula matching, no

110
00:05:55.040 --> 00:06:00.480
<v Speaker 1>nested conditional statements pretending to be logic. It's just code, predictable, readable, testable.

111
00:06:00.920 --> 00:06:03.360
<v Speaker 1>If low code was lego. You build from what you're given.

112
00:06:03.560 --> 00:06:06.040
<v Speaker 1>Then code apps is the three D printer that fabricates

113
00:06:06.040 --> 00:06:08.879
<v Speaker 1>your own bricks. You're not confined to prefab shapes. You're

114
00:06:08.879 --> 00:06:12.279
<v Speaker 1>sculpting your own UI logic and components. That's why pro

115
00:06:12.360 --> 00:06:14.839
<v Speaker 1>coders love this world. It's still the power platform, but

116
00:06:14.920 --> 00:06:18.839
<v Speaker 1>it respects their intelligence. Imagine this life cycle. Openvs code

117
00:06:18.879 --> 00:06:21.720
<v Speaker 1>type away, test locally on your machine with NPM, run

118
00:06:21.759 --> 00:06:24.639
<v Speaker 1>dev fix, test again, and when satisfied, push the app

119
00:06:24.680 --> 00:06:28.319
<v Speaker 1>to power apps with one command parks code push. Moments later,

120
00:06:28.480 --> 00:06:32.480
<v Speaker 1>your React app appears alongside standard canvas apps within your environment,

121
00:06:32.680 --> 00:06:37.319
<v Speaker 1>inherits all the environment's governance policies, and crucially authenticates automatically

122
00:06:37.439 --> 00:06:41.040
<v Speaker 1>using Microsoft Entra. You're still compliant with organizational rules, but

123
00:06:41.079 --> 00:06:43.319
<v Speaker 1>now you can finally write your own logic without fighting

124
00:06:43.319 --> 00:06:46.480
<v Speaker 1>abstraction layers. The real joy isn't just the technology, it's

125
00:06:46.519 --> 00:06:50.879
<v Speaker 1>the structure. Source control through GIT becomes standard, Collaboration through

126
00:06:50.920 --> 00:06:55.879
<v Speaker 1>pull requests becomes possible, CICD pipelines become trivial. Every software

127
00:06:55.879 --> 00:06:58.839
<v Speaker 1>engineer who's ever cried over a corrupted power effects formula

128
00:06:58.920 --> 00:07:02.879
<v Speaker 1>can now relax. Versioning isn't a dream, it's baseline reality.

129
00:07:03.199 --> 00:07:05.560
<v Speaker 1>And yet Microsoft knew this wasn't enough. Even though code

130
00:07:05.560 --> 00:07:08.600
<v Speaker 1>apps made real code first class citizens again, productivity was

131
00:07:08.639 --> 00:07:11.079
<v Speaker 1>still bottlenecked by the same thing that plagues every dev

132
00:07:11.079 --> 00:07:16.639
<v Speaker 1>shop repetition type, imports, connector calls, data mappings, all boiler plate. Powerful, yes,

133
00:07:16.680 --> 00:07:18.839
<v Speaker 1>but tedious, which is why the next piece of the

134
00:07:18.839 --> 00:07:22.879
<v Speaker 1>puzzle isn't another framework or SDK. It's something far more intoxicating,

135
00:07:23.040 --> 00:07:27.120
<v Speaker 1>artificial intelligence. Microsoft didn't just bring back structure, it brought

136
00:07:27.120 --> 00:07:30.600
<v Speaker 1>a sidekick. The next era of power apps development starts

137
00:07:30.600 --> 00:07:33.160
<v Speaker 1>with a line we never thought we'd say, GitHub copilot

138
00:07:33.240 --> 00:07:37.560
<v Speaker 1>build this for me. GitHub Copilot the Vibe partner. Now,

139
00:07:37.639 --> 00:07:39.600
<v Speaker 1>let's talk about the intern no one paid for, but

140
00:07:39.639 --> 00:07:42.360
<v Speaker 1>everyone relies on GitHub Copilot. You could call it auto

141
00:07:42.360 --> 00:07:45.360
<v Speaker 1>complete on caffeine, but that undertells what it's doing for

142
00:07:45.439 --> 00:07:48.319
<v Speaker 1>power apps developers. In this new Vibe code world, Copilot

143
00:07:48.319 --> 00:07:51.160
<v Speaker 1>isn't just a helper. It's a silent collaborator, one who

144
00:07:51.199 --> 00:07:53.839
<v Speaker 1>writes entire sections of code before your brains had time

145
00:07:53.879 --> 00:07:57.879
<v Speaker 1>to catch up. Let's establish boundaries. First. Copilot doesn't create strategy.

146
00:07:57.920 --> 00:08:02.120
<v Speaker 1>It composes syntax. You the devel define what needs to exist,

147
00:08:02.240 --> 00:08:07.439
<v Speaker 1>a dashboard, a form, a data poll from SharePoint. Copilot

148
00:08:07.480 --> 00:08:11.600
<v Speaker 1>handles the gruntwork, scaffolding components, writing JSX, fetching data, fixing

149
00:08:11.600 --> 00:08:15.600
<v Speaker 1>built errors, streamlining imports. It remembers your context across the session,

150
00:08:15.639 --> 00:08:17.959
<v Speaker 1>so by the time you say add a profile card

151
00:08:18.000 --> 00:08:21.120
<v Speaker 1>that shows username, email, and photo, it's already typing. You

152
00:08:21.160 --> 00:08:24.399
<v Speaker 1>watch React components assemble themselves in real time, and for

153
00:08:24.480 --> 00:08:27.759
<v Speaker 1>one brief second, you think maybe sky Neet deserves forgiveness.

154
00:08:27.879 --> 00:08:31.439
<v Speaker 1>This is the power amplification layer that transforms good developers

155
00:08:31.519 --> 00:08:35.440
<v Speaker 1>into fast ones. Suddenly code apps, development moves at startup Velocity.

156
00:08:35.600 --> 00:08:37.840
<v Speaker 1>Need to hook into data verse, type one comment and

157
00:08:37.879 --> 00:08:41.120
<v Speaker 1>Copilot spits out a full service interface wired to your connection.

158
00:08:41.639 --> 00:08:44.080
<v Speaker 1>Want to display a SharePoint list as a Kanban board,

159
00:08:44.399 --> 00:08:47.879
<v Speaker 1>Ask politely, and within seconds you've got dragable swim lanes

160
00:08:47.919 --> 00:08:51.080
<v Speaker 1>powered by modern React state management efficiency. That used to

161
00:08:51.080 --> 00:08:54.279
<v Speaker 1>take a sprint now takes a coffee. The analogy rights itself.

162
00:08:54.559 --> 00:08:57.600
<v Speaker 1>Copilot isn't your creative director. It's the intern who never

163
00:08:57.639 --> 00:09:00.039
<v Speaker 1>sleeps types one hundred and twenty words per minute and

164
00:09:00.120 --> 00:09:03.080
<v Speaker 1>doesn't complain about documentation. It fills in the blanks while

165
00:09:03.080 --> 00:09:05.960
<v Speaker 1>you guide the architecture, and when you test and iterate,

166
00:09:06.320 --> 00:09:09.679
<v Speaker 1>it learns patterns from your prompts, becoming eerily good at

167
00:09:09.679 --> 00:09:12.559
<v Speaker 1>predicting your next component or data model. It's not AI

168
00:09:12.639 --> 00:09:16.639
<v Speaker 1>replaces programmers. It's AI removes the typing part of programming, which,

169
00:09:16.799 --> 00:09:19.399
<v Speaker 1>let's face it is the boring part anyway. But before

170
00:09:19.440 --> 00:09:23.320
<v Speaker 1>you start deploying blindly, here's the serious note. Copilot accelerate syntax,

171
00:09:23.360 --> 00:09:26.120
<v Speaker 1>not semantics. It can write error free code that's conceptually

172
00:09:26.159 --> 00:09:29.440
<v Speaker 1>wrong if you're not watching. That's why discipline reviews, testing,

173
00:09:29.519 --> 00:09:32.639
<v Speaker 1>source control matters more than ever. Let Copilot generate you

174
00:09:32.720 --> 00:09:36.919
<v Speaker 1>validate that partnership, not automation, is the smart developers advantage.

175
00:09:37.240 --> 00:09:40.320
<v Speaker 1>When this dynamic plays out inside the Power platform, something

176
00:09:40.360 --> 00:09:44.679
<v Speaker 1>magical and pragmatic happens. Enterprises suddenly gain the speed of

177
00:09:44.679 --> 00:09:48.639
<v Speaker 1>citizen development with the integrity of professional code. Business users

178
00:09:48.639 --> 00:09:52.039
<v Speaker 1>get their features faster, it gets its governance, and developers

179
00:09:52.039 --> 00:09:54.320
<v Speaker 1>get out of the swamp of repetitive front and plumbing.

180
00:09:54.399 --> 00:09:58.480
<v Speaker 1>Everybody wins, including Microsoft's server utilization metrics. The net effect

181
00:09:58.639 --> 00:10:01.440
<v Speaker 1>power apps code apps power brought by Copilot feel less

182
00:10:01.480 --> 00:10:05.679
<v Speaker 1>like systems development and more like orchestrating intelligence. You describe intentions,

183
00:10:06.000 --> 00:10:08.960
<v Speaker 1>the machine translates them into running code, all within a

184
00:10:09.000 --> 00:10:12.919
<v Speaker 1>governed environment with secure authentication and managed connectors. So now

185
00:10:13.080 --> 00:10:16.480
<v Speaker 1>both worlds low code and vibe Code are in full motion,

186
00:10:16.919 --> 00:10:21.159
<v Speaker 1>one democratizing creation, the other formalizing scale. But which one

187
00:10:21.200 --> 00:10:24.399
<v Speaker 1>should drive your next project? That's the question professionals are

188
00:10:24.440 --> 00:10:27.399
<v Speaker 1>about to ask in every strategy meeting, because we've tasted

189
00:10:27.399 --> 00:10:30.000
<v Speaker 1>both speed and structure and we're not going back. The

190
00:10:30.039 --> 00:10:33.399
<v Speaker 1>next section decides the winner, vibe code versus Low code,

191
00:10:33.519 --> 00:10:37.759
<v Speaker 1>choosing your weapon. Here's where the philosophical turns practical. Low

192
00:10:37.799 --> 00:10:40.919
<v Speaker 1>code and vibe code aren't moral choices, they are strategic ones.

193
00:10:41.200 --> 00:10:45.000
<v Speaker 1>Both sound enticing. One gives anyone the illusion of instant productivity.

194
00:10:45.240 --> 00:10:48.480
<v Speaker 1>The other offers precise control and a feint whiff of superiority.

195
00:10:48.679 --> 00:10:50.879
<v Speaker 1>The truth you need to know when speed matters more

196
00:10:50.919 --> 00:10:54.159
<v Speaker 1>than architecture, and when governance speeds enthusiasm. Because whether you're

197
00:10:54.240 --> 00:10:57.440
<v Speaker 1>orchestrating a single workflow or a platform portfolio, your weapon

198
00:10:57.480 --> 00:11:00.799
<v Speaker 1>defines your outcome. Start with development work force. Low code

199
00:11:00.840 --> 00:11:03.960
<v Speaker 1>feels friendly because it's graphical. You drag configure and get

200
00:11:03.960 --> 00:11:07.039
<v Speaker 1>that satisfying spark when something actually works. No syntax error

201
00:11:07.039 --> 00:11:09.480
<v Speaker 1>is no failed bills, just a functioning form. But what

202
00:11:09.600 --> 00:11:13.120
<v Speaker 1>you gain in approachability you lose in reusability. Components can't

203
00:11:13.120 --> 00:11:17.360
<v Speaker 1>easily travel between apps. Refactoring means opening interfaces one by one.

204
00:11:17.600 --> 00:11:21.799
<v Speaker 1>Debugging feels like deciphering hieroglyphs. Vibe code, in contrast, trades

205
00:11:21.879 --> 00:11:24.879
<v Speaker 1>ease for power. You live in visual studio code. The

206
00:11:24.919 --> 00:11:27.399
<v Speaker 1>CLI is your home and GIT is your safety net.

207
00:11:27.600 --> 00:11:30.279
<v Speaker 1>You structure your code base, share modules between apps, and

208
00:11:30.320 --> 00:11:33.440
<v Speaker 1>automate everything from bill to deploy the qui. Devotees may

209
00:11:33.440 --> 00:11:36.759
<v Speaker 1>call it overkill. Engineers call it Tuesday. Governance is where

210
00:11:36.799 --> 00:11:39.519
<v Speaker 1>the gap widens into a canyon. Low code operates within

211
00:11:39.559 --> 00:11:43.879
<v Speaker 1>power platform environments, useful for departmental scalability, but bound by

212
00:11:43.879 --> 00:11:47.360
<v Speaker 1>whatever DLP and data boundary policies the admins install. Great

213
00:11:47.360 --> 00:11:50.720
<v Speaker 1>for insulation, not great for orchestration. Code apps, on the

214
00:11:50.759 --> 00:11:53.799
<v Speaker 1>other hand, sync directly with DevOps pipelines. You can enforce

215
00:11:53.799 --> 00:11:58.000
<v Speaker 1>pull request approvals, automated testing, linting, even semantic versioning. That's

216
00:11:58.039 --> 00:12:01.639
<v Speaker 1>not bureaucracy, it's survival. When multiple teams are shipping changes weekly,

217
00:12:02.000 --> 00:12:05.120
<v Speaker 1>governance becomes a feature, not a complaint. Performance follows the

218
00:12:05.120 --> 00:12:07.879
<v Speaker 1>same pattern in low code. Abstruction protects you, but also

219
00:12:07.919 --> 00:12:10.600
<v Speaker 1>handcuffs you. Every button press runs through layers of the

220
00:12:10.639 --> 00:12:14.080
<v Speaker 1>power effects interpreter, then into connector middleware. Then finally to

221
00:12:14.120 --> 00:12:17.679
<v Speaker 1>the data source. Efficient enough for most business use cases. Yes,

222
00:12:18.080 --> 00:12:21.080
<v Speaker 1>but if you need real time dashboards, dynamic rendering, or

223
00:12:21.159 --> 00:12:24.600
<v Speaker 1>high volume processing, those invisible layers turn into molasses. Code

224
00:12:24.600 --> 00:12:27.559
<v Speaker 1>apps shed the fat react handle state in the browser.

225
00:12:27.919 --> 00:12:32.279
<v Speaker 1>JavaScript calls connectors directly through SDK rendering is immediate. It's

226
00:12:32.320 --> 00:12:34.399
<v Speaker 1>like comparing a high level language lesson to a live

227
00:12:34.440 --> 00:12:37.440
<v Speaker 1>circuit demonstration. The latter sparks faster and you can actually

228
00:12:37.519 --> 00:12:40.879
<v Speaker 1>see the current Security isn't as divisive as people assume.

229
00:12:41.080 --> 00:12:44.919
<v Speaker 1>Both worlds live under Microsoft intra authentication. Both obey conditional

230
00:12:44.919 --> 00:12:48.759
<v Speaker 1>access encryption and tenant boundaries. The nuance is granularity. Low

231
00:12:48.759 --> 00:12:53.000
<v Speaker 1>code enforces security through configuration checkboxes, roll tables, and access

232
00:12:53.000 --> 00:12:56.679
<v Speaker 1>lists find for most tasks, limiting for anything. Nuanced code

233
00:12:56.679 --> 00:13:00.639
<v Speaker 1>apps bake insecurity logic right inside your code, roll validation

234
00:13:00.679 --> 00:13:04.039
<v Speaker 1>at run time, custom API calls with token handling dynamic

235
00:13:04.039 --> 00:13:06.159
<v Speaker 1>permission based UI. In other words, you can make the

236
00:13:06.159 --> 00:13:09.000
<v Speaker 1>app itself smart enough to know who's poking around. That

237
00:13:09.120 --> 00:13:11.840
<v Speaker 1>level of control matters when who clicked what could be

238
00:13:11.879 --> 00:13:14.720
<v Speaker 1>an audit question, not just a metric maintenance is the

239
00:13:14.799 --> 00:13:18.159
<v Speaker 1>quiet killer. Low code wins at inception. An app built

240
00:13:18.159 --> 00:13:22.159
<v Speaker 1>in hours, but eventually collapses under its own shortcuts. Connectors

241
00:13:22.159 --> 00:13:26.440
<v Speaker 1>get deprecated, controls change behavior, formulas break when data types evolve.

242
00:13:26.879 --> 00:13:29.480
<v Speaker 1>Each fix is manual because the code isn't really text

243
00:13:29.759 --> 00:13:33.480
<v Speaker 1>its configuration. Meanwhile, code apps live and die by git commits.

244
00:13:33.519 --> 00:13:37.159
<v Speaker 1>You can branch, merge, roll back, and recompile. When Microsoft

245
00:13:37.279 --> 00:13:40.919
<v Speaker 1>changes SDK versions, you update your packages and rebuild, not

246
00:13:41.039 --> 00:13:44.960
<v Speaker 1>rewire everything manually. Longevity favors code, not convenience. Then there's

247
00:13:45.000 --> 00:13:47.720
<v Speaker 1>team alignment. If your builders are business analysts who know

248
00:13:47.759 --> 00:13:50.679
<v Speaker 1>processes but hate syntax, low code is the natural arena.

249
00:13:51.120 --> 00:13:53.639
<v Speaker 1>They understand what needs doing and thrive in a system

250
00:13:53.639 --> 00:13:56.879
<v Speaker 1>that abstracts the details. But once you involve developers, those

251
00:13:56.919 --> 00:13:59.440
<v Speaker 1>who speak Jason fluently and scoff at drag and drop,

252
00:13:59.639 --> 00:14:02.320
<v Speaker 1>forcing them into canvas apps is like asking a surgeon

253
00:14:02.360 --> 00:14:05.639
<v Speaker 1>to operate with mittens. Give them the keyboard, the CLI,

254
00:14:05.720 --> 00:14:09.480
<v Speaker 1>and the repository and they'll deliver something maintainable rather than mystical.

255
00:14:09.559 --> 00:14:12.679
<v Speaker 1>Let's ground this in miniature reality checks. Suppose the HR

256
00:14:12.720 --> 00:14:15.679
<v Speaker 1>department wants a tool that automates employee onboarding right from

257
00:14:15.679 --> 00:14:19.879
<v Speaker 1>a SharePoint list, triggers emails, updates, data verse rows flax

258
00:14:19.919 --> 00:14:23.120
<v Speaker 1>it tasks. That's a perfect low code play, fast, functional,

259
00:14:23.120 --> 00:14:26.480
<v Speaker 1>self contained, low risk. Now picture a manufacturing division needing

260
00:14:26.480 --> 00:14:29.720
<v Speaker 1>a system that pulls data from SQL, external APIs and

261
00:14:29.759 --> 00:14:33.399
<v Speaker 1>IoT telemetry with customized charts and responsive dashboards. That's not

262
00:14:33.440 --> 00:14:36.200
<v Speaker 1>a canvas problem. That's a code app destiny. Low code

263
00:14:36.240 --> 00:14:38.919
<v Speaker 1>can imitate such complexity, but at the cost of maintainability.

264
00:14:39.200 --> 00:14:42.440
<v Speaker 1>Vibe code starts there naturally. Here's where it gets amusing.

265
00:14:42.840 --> 00:14:46.919
<v Speaker 1>Despite the power gap, low code isn't disappearing, it's mutating.

266
00:14:47.159 --> 00:14:50.360
<v Speaker 1>The future isn't a coup where developers overthrow citizen creators.

267
00:14:50.440 --> 00:14:53.600
<v Speaker 1>It's a coalition. Hybrid bills already exist, Canvas apps embedding

268
00:14:53.600 --> 00:14:57.600
<v Speaker 1>custom react components, code apps consuming connectors originally configured in

269
00:14:57.679 --> 00:15:00.919
<v Speaker 1>low code. Think of it as distributed intelligence. One side

270
00:15:00.919 --> 00:15:05.000
<v Speaker 1>prototypes ideas quickly, the other scales them properly. When both coexist,

271
00:15:05.120 --> 00:15:08.240
<v Speaker 1>the entire power platform transforms from tooling chaos to a

272
00:15:08.279 --> 00:15:12.240
<v Speaker 1>cohesive development ecosystem. And yes, there's irony. The platform built

273
00:15:12.240 --> 00:15:15.120
<v Speaker 1>to eliminate code now depends on it again, but elegantly,

274
00:15:15.200 --> 00:15:19.279
<v Speaker 1>with AI accelerating both sides. Vibecode doesn't declare war on

275
00:15:19.320 --> 00:15:21.720
<v Speaker 1>low code. It offers an exit from its limitations while

276
00:15:21.799 --> 00:15:24.080
<v Speaker 1>keeping the ease that made it popular in the first place.

277
00:15:24.440 --> 00:15:28.960
<v Speaker 1>Canvas empowers creativity, code ensures continuity. Together they form a

278
00:15:29.000 --> 00:15:32.279
<v Speaker 1>closed loop of innovation and governance, Microsoft's favorite love story.

279
00:15:32.639 --> 00:15:35.519
<v Speaker 1>When you start viewing power Platform this way, debates about

280
00:15:35.559 --> 00:15:39.120
<v Speaker 1>which one's better sound childish. A hammer isn't better than

281
00:15:39.120 --> 00:15:42.399
<v Speaker 1>a wrench. They're just different tools for different bolts. The

282
00:15:42.480 --> 00:15:44.799
<v Speaker 1>real skill is knowing when you need fine talk or

283
00:15:44.960 --> 00:15:48.559
<v Speaker 1>blunt impact. The best architects design systems that mix both

284
00:15:48.720 --> 00:15:52.639
<v Speaker 1>quick prototypes through low code, hardened modules through vibecode, or

285
00:15:52.679 --> 00:15:56.399
<v Speaker 1>wrapped by copilot's AI suggestions, humming like quiet machinery behind

286
00:15:56.399 --> 00:15:59.799
<v Speaker 1>the scenes. That's the equilibrium professionals are heading toward. Rapid

287
00:15:59.840 --> 00:16:03.440
<v Speaker 1>eye DA married to disciplined execution. The platform isn't bifurcating,

288
00:16:03.480 --> 00:16:07.320
<v Speaker 1>it's specializing. So before you pick sides, remember the weapon

289
00:16:07.320 --> 00:16:10.720
<v Speaker 1>doesn't make the warrior. It just makes their job faster, cleaner, and,

290
00:16:10.919 --> 00:16:13.799
<v Speaker 1>in the case of power apps, significantly more compliant. When

291
00:16:14.120 --> 00:16:18.200
<v Speaker 1>the strategic layer AI, governance and the future of Power Platform.

292
00:16:18.480 --> 00:16:21.080
<v Speaker 1>Here's the part most people miss. Microsoft isn't staging a

293
00:16:21.120 --> 00:16:24.519
<v Speaker 1>coding war, it's engineering a merger. The power Platform's future

294
00:16:24.559 --> 00:16:27.720
<v Speaker 1>isn't low code versus pro code. It's the unification of

295
00:16:27.759 --> 00:16:30.840
<v Speaker 1>both underneath a shared governance and AI driven architecture, a

296
00:16:30.879 --> 00:16:34.279
<v Speaker 1>single nervous system that connects every creative impulse to enterprise

297
00:16:34.320 --> 00:16:36.840
<v Speaker 1>grade control. Think of it less like two camps and

298
00:16:36.919 --> 00:16:40.159
<v Speaker 1>more like one ecosystem learning to self regulate. The strategic

299
00:16:40.279 --> 00:16:43.799
<v Speaker 1>layer is where this evolution becomes visible. At a technical level,

300
00:16:43.840 --> 00:16:48.559
<v Speaker 1>everything's converging around three pillars, Copilot, data verse, and governed extensibility.

301
00:16:48.639 --> 00:16:52.559
<v Speaker 1>Copilot Studio now writes connectors that previously required manual SDK calls,

302
00:16:53.000 --> 00:16:55.960
<v Speaker 1>code components, the tech that lets react or typescript controls

303
00:16:56.039 --> 00:16:59.360
<v Speaker 1>run inside canvas apps are dissolving the wall between citizen

304
00:16:59.399 --> 00:17:03.000
<v Speaker 1>and professional creation and data verse. The central data service,

305
00:17:03.039 --> 00:17:06.200
<v Speaker 1>once reserved for model driven purists, is now the ground

306
00:17:06.240 --> 00:17:09.359
<v Speaker 1>both camps stand on. It provides the schema, security, and

307
00:17:09.440 --> 00:17:12.359
<v Speaker 1>relationship logic that make all these disparate bits behave like

308
00:17:12.400 --> 00:17:14.960
<v Speaker 1>one organism. Picture the platform as a living body. The

309
00:17:15.000 --> 00:17:19.319
<v Speaker 1>citizen developers are its cells, rapidly generating new tissue, dashboards,

310
00:17:19.480 --> 00:17:23.680
<v Speaker 1>forms workflows. The developers are the neurons linking those cells together,

311
00:17:23.839 --> 00:17:27.880
<v Speaker 1>refining reflexes, ensuring the organism thinks before it moves. Governance

312
00:17:27.920 --> 00:17:31.440
<v Speaker 1>meanwhile acts as the immune system, preventing rogue cells from

313
00:17:31.480 --> 00:17:35.880
<v Speaker 1>spawning unapproved connectors or violating data policies. Add AI, and

314
00:17:35.960 --> 00:17:38.920
<v Speaker 1>suddenly that body starts predicting rather than merely reacting to

315
00:17:38.920 --> 00:17:42.079
<v Speaker 1>business needs. From a business perspective, this is gold. It

316
00:17:42.160 --> 00:17:45.640
<v Speaker 1>standardizes deployment pipelines so that every app, whether built by

317
00:17:45.640 --> 00:17:49.960
<v Speaker 1>marketing or engineering, travels through the same CICD arteries. It

318
00:17:50.000 --> 00:17:54.720
<v Speaker 1>centralizes monitoring, security and compliance while preserving creative autonomy. Citizen

319
00:17:54.799 --> 00:17:59.680
<v Speaker 1>devs get to experiment, it gets traceability, leadership gets measurable ROI.

320
00:18:00.519 --> 00:18:04.119
<v Speaker 1>Everyone's incentives aligned finally under one architecture. Instead of fighting

321
00:18:04.119 --> 00:18:07.519
<v Speaker 1>overtooling the air layer cements This true copilot doesn't favor

322
00:18:07.559 --> 00:18:10.799
<v Speaker 1>coders or citizens, it interprets both. To the business user,

323
00:18:11.240 --> 00:18:14.920
<v Speaker 1>it feels like natural language magic. Build me a project

324
00:18:14.920 --> 00:18:18.559
<v Speaker 1>tracker results in an instant canvas skeleton, data verse table,

325
00:18:18.640 --> 00:18:21.640
<v Speaker 1>and basic logic. To the developer, the same engine offers

326
00:18:21.680 --> 00:18:25.839
<v Speaker 1>code suggestions, connector templates, and function scaffolds that would otherwise

327
00:18:25.880 --> 00:18:29.000
<v Speaker 1>eat ours. It's two dialects, English and JavaScript, spoken through

328
00:18:29.000 --> 00:18:31.359
<v Speaker 1>one interpreter. That never sleeps. There's a term for what's

329
00:18:31.400 --> 00:18:35.039
<v Speaker 1>forming governed expressiveness. It's no longer about who can code.

330
00:18:35.039 --> 00:18:38.079
<v Speaker 1>It's about how efficiently each person can express intent and

331
00:18:38.119 --> 00:18:42.440
<v Speaker 1>how safely that intent is deployed. Microsoft's architecture quietly enforces

332
00:18:42.440 --> 00:18:47.079
<v Speaker 1>this balance through policies, environment segmentation, and now Copilot augmented

333
00:18:47.079 --> 00:18:50.960
<v Speaker 1>guidance baked directly into the ide. Its democratization without entropy,

334
00:18:51.200 --> 00:18:54.119
<v Speaker 1>the near future looks less like no code versus full code,

335
00:18:54.119 --> 00:18:57.039
<v Speaker 1>and more like a spectrum of expressiveness per citizen. Someone

336
00:18:57.039 --> 00:18:59.960
<v Speaker 1>building an Excel might graduate to power effects, a power

337
00:19:00.440 --> 00:19:03.680
<v Speaker 1>X user might evolve into writing typescript components, and a

338
00:19:03.720 --> 00:19:06.519
<v Speaker 1>pro dev might prototype new features in low code before

339
00:19:06.559 --> 00:19:09.920
<v Speaker 1>hardening them in React. It's a circular ladder that keeps

340
00:19:09.920 --> 00:19:13.440
<v Speaker 1>everyone contributing at their comfort level without breaking the ecosystem.

341
00:19:13.519 --> 00:19:16.200
<v Speaker 1>This is what vibe coding actually signals. It's not just

342
00:19:16.240 --> 00:19:18.960
<v Speaker 1>writing code with Flare. It's coding that feels like low code,

343
00:19:19.079 --> 00:19:22.200
<v Speaker 1>fast iterative, assisted by AI, but scales like pro code

344
00:19:22.359 --> 00:19:26.680
<v Speaker 1>environments sink to get pipelines, validate deployments. Copilot teaches best

345
00:19:26.680 --> 00:19:31.119
<v Speaker 1>practices invisibly. The experience smooths into one continuous motion between

346
00:19:31.119 --> 00:19:34.720
<v Speaker 1>thinking and building. In effect, power platform becomes a composable brain,

347
00:19:35.359 --> 00:19:39.559
<v Speaker 1>absorbing new patterns from every user, whether they drag components

348
00:19:39.720 --> 00:19:43.799
<v Speaker 1>or refactor functions. That's the strategic horizon and enterprise platform

349
00:19:43.839 --> 00:19:46.960
<v Speaker 1>behaving like collective intelligence. When you see it that way,

350
00:19:47.000 --> 00:19:49.880
<v Speaker 1>the vibe in vibe Coode stops sounding mystical. It's the

351
00:19:49.920 --> 00:19:54.359
<v Speaker 1>resonance between freedom and discipline, between human creativity and machine governance,

352
00:19:54.400 --> 00:19:57.839
<v Speaker 1>and when those vibrations align, the whole system hums the

353
00:19:57.920 --> 00:20:01.160
<v Speaker 1>real truth. Here's the truth stripped of c Logan power apps.

354
00:20:01.240 --> 00:20:04.079
<v Speaker 1>Vibe code isn't killing low code, It's correcting its excesses.

355
00:20:04.200 --> 00:20:07.839
<v Speaker 1>It's the gentle realization that unlimited citizen freedom without rules

356
00:20:07.880 --> 00:20:11.200
<v Speaker 1>turns into messes. Only pro devs can mop up. Vibe

357
00:20:11.240 --> 00:20:16.359
<v Speaker 1>code returns structure, visibility, and maintainability without dismantling the empowerment

358
00:20:16.400 --> 00:20:18.680
<v Speaker 1>that made low codes succeed in the first place. So

359
00:20:18.880 --> 00:20:21.799
<v Speaker 1>use low code for velocity, spin up prototypes, validate ideas,

360
00:20:21.839 --> 00:20:24.759
<v Speaker 1>prove concepts, then expand them using vibe Coode for longevity,

361
00:20:25.039 --> 00:20:29.880
<v Speaker 1>version components, real frameworks, automated deployment, and through it all,

362
00:20:30.039 --> 00:20:33.640
<v Speaker 1>let GitHub copilot unify both worlds. Your silent translator between

363
00:20:33.680 --> 00:20:36.480
<v Speaker 1>business logic and technical syntax. The moment you treat AI

364
00:20:36.559 --> 00:20:39.440
<v Speaker 1>as the bridge, not the replacement, you start developing at

365
00:20:39.480 --> 00:20:41.799
<v Speaker 1>the speed of thought and the discipline of engineering. The

366
00:20:41.799 --> 00:20:45.559
<v Speaker 1>power platform isn't splitting apart. It's evolving toward composable intelligence,

367
00:20:45.960 --> 00:20:49.880
<v Speaker 1>where every workflow app and connector plugs into a shared

368
00:20:49.920 --> 00:20:53.599
<v Speaker 1>mental model of the organization. That's the real transformation, not

369
00:20:53.680 --> 00:20:56.480
<v Speaker 1>faster forms, but smarter systems that learn from how you build.

370
00:20:56.759 --> 00:20:59.000
<v Speaker 1>If that vision saves you time or spares you another

371
00:20:59.039 --> 00:21:03.200
<v Speaker 1>governance post mortem, repay the favor, subscribe, tap follow, and

372
00:21:03.319 --> 00:21:06.319
<v Speaker 1>let the next deep dive arrive automatically, like a scheduled

373
00:21:06.359 --> 00:21:09.240
<v Speaker 1>power automated flow knowledge should update itself proceed